Transformers--4-37-中文文档-十二-

Transformers 4.37 中文文档（十二）

原文：huggingface.co/docs/transformers

BERTweet

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/bertweet

概述

BERTweet 模型是由 Dat Quoc Nguyen、Thanh Vu 和 Anh Tuan Nguyen 在BERTweet: A pre-trained language model for English Tweets中提出的。

从论文中摘录如下：

我们提出了 BERTweet，这是第一个用于英文推文的公开大规模预训练语言模型。我们的 BERTweet 与 BERT-base（Devlin 等人，2019）具有相同的架构，使用 RoBERTa 预训练过程进行训练（Liu 等人，2019）。实验表明，BERTweet 优于强基线 RoBERTa-base 和 XLM-R-base（Conneau 等人，2020），在三个推文 NLP 任务（词性标注、命名实体识别和文本分类）上产生比先前最先进模型更好的性能结果。

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

用法示例

>>> import torch
>>> from transformers import AutoModel, AutoTokenizer

>>> bertweet = AutoModel.from_pretrained("vinai/bertweet-base")

>>> # For transformers v4.x+:
>>> tokenizer = AutoTokenizer.from_pretrained("vinai/bertweet-base", use_fast=False)

>>> # For transformers v3.x:
>>> # tokenizer = AutoTokenizer.from_pretrained("vinai/bertweet-base")

>>> # INPUT TWEET IS ALREADY NORMALIZED!
>>> line = "SC has first two presumptive cases of coronavirus , DHEC confirms HTTPURL via @USER :cry:"

>>> input_ids = torch.tensor([tokenizer.encode(line)])

>>> with torch.no_grad():
...     features = bertweet(input_ids)  # Models outputs are now tuples

>>> # With TensorFlow 2.0+:
>>> # from transformers import TFAutoModel
>>> # bertweet = TFAutoModel.from_pretrained("vinai/bertweet-base")

此实现与 BERT 相同，仅在分词方法上有所不同。有关 API 参考信息，请参考 BERT 文档。

BertweetTokenizer

class transformers.BertweetTokenizer

<来源>

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

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• normalization (bool, optional, defaults to False) — 是否应用规范化预处理。

• 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>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

构建一个使用字节对编码的 BERTweet 分词器。

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

add_from_file

<来源>

( f )

从文本文件加载预先存在的字典，并将其符号添加到此实例。

build_inputs_with_special_tokens

<来源>

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

参数

• token_ids_0（List[int]）— 要添加特殊标记的 ID 列表。

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

返回

List[int]

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

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

• 单个序列：<s> X </s>

• 序列对：<s> A </s></s> B </s>

convert_tokens_to_string

<来源>

( tokens )

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0（List[int]）— ID 列表。

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

返回

List[int]

零列表。

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

get_special_tokens_mask

<来源>

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

参数

• token_ids_0（List[int]）— ID 列表。

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

• already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经使用特殊标记格式化。

返回

List[int]

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

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

normalizeToken

<来源>

( token )

规范化推文中的标记

normalizeTweet

<来源>

( tweet )

规范化原始推文

BigBird

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

概述

BigBird 模型是由 Zaheer, Manzil 和 Guruganesh, Guru 和 Dubey, Kumar Avinava 和 Ainslie, Joshua 和 Alberti, Chris 和 Ontanon, Santiago 和 Pham, Philip 和 Ravula, Anirudh 和 Wang, Qifan 和 Yang, Li 等人在Big Bird: Transformers for Longer Sequences中提出的。BigBird 是一种基于稀疏注意力的变压器，它将基于 Transformer 的模型（如 BERT）扩展到更长的序列。除了稀疏注意力，BigBird 还将全局注意力以及随机注意力应用于输入序列。从理论上讲，已经证明应用稀疏、全局和随机注意力可以逼近完全注意力，同时对于更长的序列而言在计算上更加高效。由于具有处理更长上下文的能力，BigBird 在各种长文档 NLP 任务（如问答和摘要）上表现出比 BERT 或 RoBERTa 更好的性能。

论文摘要如下：

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

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

使用提示

• 有关 BigBird 注意力工作的详细解释，请参阅此博客文章。

• BigBird 有两种实现：original_full和block_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, optional, defaults to 50358) — BigBird 模型的词汇表大小。定义了在调用 BigBirdModel 时可以表示的不同标记数量。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu_new") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 4096) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，1024、2048 或 4096）。

• type_vocab_size (int, optional, defaults to 2) — 在调用 BigBirdModel 时传递的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• is_decoder (bool, optional, defaults to False) — 模型是否用作解码器。如果为 False，则模型用作编码器。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。

• attention_type (str, optional, defaults to "block_sparse") — 是否使用在论文中介绍的块稀疏注意力（具有 n 复杂度）或原始注意力层（具有 n² 复杂度）。可能的值为 "original_full" 和 "block_sparse"。

• use_bias (bool, optional, defaults to True) — 是否在查询、键、值中使用偏置。

• rescale_embeddings (bool, optional, defaults to False) — 是否使用 (hidden_size ** 0.5) 重新缩放嵌入。

• block_size (int, optional, defaults to 64) — 每个块的大小。仅在 attention_type == "block_sparse" 时有用。

• num_random_blocks (int, optional, defaults to 3) — 每个查询将关注这么多个随机块。仅在 attention_type == "block_sparse" 时有用。

• classifier_dropout (float, optional) — 分类头部的 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

< source >

( 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: Optional = None **kwargs )

参数

• vocab_file (str) — 包含实例化分词器所需词汇表的SentencePiece文件（通常具有.spm扩展名）。

• unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• bos_token (str, 可选, 默认为 "<s>") — 序列开始标记。

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

• pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• sep_token (str, 可选, 默认为 "[SEP]") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作带有特殊标记的序列的最后一个标记。

• mask_token (str, 可选, 默认为 "[MASK]") — 用于屏蔽值的标记。这是在使用屏蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• cls_token (str, 可选, 默认为 "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记进行分类）。在构建带有特殊标记的序列时，它是序列的第一个标记。

• 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 为无限，并使用前向过滤和后向抽样算法从所有假设（格）中抽样。

  • alpha: 用于 unigram 抽样的平滑参数，以及 BPE-dropout 的合并操作的丢弃概率。

构建一个 BigBird 分词器。基于SentencePiece。

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

build_inputs_with_special_tokens

< source >

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

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

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

返回

List[int]

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

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

• 单个序列: [CLS] X [SEP]

• 序列对: [CLS] A [SEP] B [SEP]

get_special_tokens_mask

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

• already_has_special_tokens (bool, optional, defaults to False) — 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

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

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

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

从传递的两个序列创建一个用于序列对分类任务的掩码。BERT 序列对掩码的格式如下: :: 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 | 第一个序列 | 第二个序列 | 如果 token_ids_1 是 None，则此方法仅返回掩码的第一部分（0）。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = 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, optional, defaults to "<s>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。.. 注意:: 在使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 sep_token。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• cls_token (str, optional, defaults to "[CLS]") — 在进行序列分类（整个序列而不是每个标记的分类）时使用的分类器标记。在使用特殊标记构建序列时，它是序列的第一个标记。

• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

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

build_inputs_with_special_tokens

< source >

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

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表

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

返回

List[int]

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

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

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

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

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 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

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

• already_has_special_tokens (bool，可选，默认为 False） — 如果标记列表已经为模型格式化了特殊标记，则设置为 True

返回

List[int]

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

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

BigBird 特定输出

class transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput

< source >

( loss: Optional = None prediction_logits: FloatTensor = None seq_relationship_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss（可选，当提供 labels 时返回，形状为 (1,) 的 torch.FloatTensor） — 作为被屏蔽的语言建模损失和下一个序列预测（分类）损失之和的总损失。

• prediction_logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• seq_relationship_logits (torch.FloatTensor of shape (batch_size, 2)) — 下一个序列预测（分类）头部的预测分数（在 SoftMax 之前的 True/False 连续性分数）。

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

  每个层输出的模型隐藏状态加上初始嵌入输出。

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

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

BigBirdForPreTraining 的输出类型。

PytorchHide Pytorch 内容

BigBirdModel

class transformers.BigBirdModel

< source >

( config add_pooling_layer = True )

参数

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

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

该模型可以作为编码器（仅具有自注意力）或解码器运行，此时在自注意力层之间添加了一个交叉注意力层，遵循 Attention is all you need 中描述的架构，作者为 Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin。

要作为解码器运行，模型需要使用配置中的 is_decoder 参数设置为 True 进行初始化。要在 Seq2Seq 模型中使用，模型需要使用 is_decoder 参数和 add_cross_attention 都设置为 True 进行初始化；然后预期将 encoder_hidden_states 作为输入传递。

forward

< source >

( input_ids: LongTensor = 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 中：

  • 1 代表未被“masked”的标记，

  • 0 代表被masked的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选取在[0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• encoder_hidden_states (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值选取在[0, 1]：

  • 1 表示标记未被掩码。

  • 0 表示被掩码的标记。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量） — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给该模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

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

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.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)) — 经过辅助预训练任务的层进一步处理后的序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重是在预训练期间从下一个句子预测（分类）目标中训练的。

• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则包括嵌入层的输出和每一层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

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

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

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或者config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果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输入）。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None next_sentence_label: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 对于未被masked的标记为 1。

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部无效的掩码。选择的掩码值在[0, 1]内：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。

• next_sentence_label（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算下一个序列预测（分类）损失的标签。如果指定，nsp 损失将添加到 masked_lm 损失中。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]内：

  • 0 表示序列 B 是序列 A 的延续，

  • 1 表示序列 B 是一个随机序列。

• kwargs（Dict[str, any]，可选，默认为{}）— 用于隐藏已弃用的旧参数的参数。

返回

transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput 或者tuple(torch.FloatTensor)

一个 transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者config.return_dict=False时）包含不同的元素，取决于配置（BigBirdConfig）和输入。

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor）— 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

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

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

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

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

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

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

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

尽管前向传递的方法需要在这个函数内定义，但应该在之后调用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 微调的语言建模头。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<来源>

( input_ids: LongTensor = 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 labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则此掩码将用于交叉注意力。掩码值在 [0, 1] 中选择：

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了 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 的标记将被忽略（masked），损失仅计算具有标签 n [0, ..., config.vocab_size] 的标记。

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

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(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时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

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

  在交叉注意力头中用于计算加权平均值的注意力 softmax 后的交叉注意力权重。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码的（见past_key_values输入）。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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()方法以加载模型权重。

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

forward

<来源>

( input_ids: LongTensor = 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 1 代表未被masked的标记，

  • 0 代表被masked的标记。

  什么是注意力掩码？

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

  • 0 对应于 sentence A 标记，

  • 1 对应于 sentence B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• 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.MaskedLMOutput 或tuple(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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出 + 每层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

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

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用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("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: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(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标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。

• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)） — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。

  模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

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

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用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("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

< source >

( config )

参数

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

BigBird 模型，顶部带有一个多选分类头（一个线性层位于池化输出之上，然后是 softmax），例如用于 RocStories/SWAG 任务。

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

forward

<来源>

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

参数

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

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

  什么是输入 IDs？

• attention_mask (torch.FloatTensor，形状为(batch_size, num_choices, sequence_length)，optional) — 用于避免在填充 token 索引上执行注意力的遮罩。遮罩值在[0, 1]中选择：

  • 1 表示未被遮蔽的 token，

  • 0 表示被遮蔽的 token。

  什么是注意力遮罩？

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

  • 0 对应于句子 A的 token，

  • 1 对应于句子 B的 token。

  什么是 token type IDs?

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 范围内，其中 num_choices 是输入张量的第二维的大小。（参见上面的 input_ids）

返回

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（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 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的输出 + 每层的输出）。

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

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

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

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

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用 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

< source >

( config )

参数

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

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

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

forward

< source >

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

参数

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

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

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充令牌索引上执行注意力的掩码。掩码值选定在[0, 1]范围内：

  • 对于未被masked的令牌，值为 1，

  • 对于被masked的令牌，值为 0。

  注意力掩码是什么？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]范围内：

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  令牌类型 ID 是什么？

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

  位置 ID 是什么？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算令牌分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回值

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。

• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）— 分类得分（SoftMax 之前）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

  每层模型的输出的隐藏状态以及可选的初始嵌入输出。

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

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

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 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

< source >

( config add_pooling_layer = False )

参数

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

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

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

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None question_lengths: 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 ) → export const metadata = 'undefined';transformers.models.big_bird.modeling_big_bird.BigBirdForQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 1 代表未被遮蔽的标记，

  • 0 代表被遮蔽的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1] 中：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是模型的内部嵌入查找矩阵。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• start_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算标记分类损失的标记范围开始位置的位置（索引）。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

• end_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算标记范围结束位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

返回

transformers.models.big_bird.modeling_big_bird.BigBirdForQuestionAnsweringModelOutput或tuple(torch.FloatTensor)

一个transformers.models.big_bird.modeling_big_bird.BigBirdForQuestionAnsweringModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（BigBirdConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）— 跨度开始分数（SoftMax 之前）。

• end_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）— 跨度结束分数（SoftMax 之前）。

• pooler_output（形状为(batch_size, 1)的torch.FloatTensor）— 来自 BigBigModel 的池化器输出

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

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

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

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

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

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用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("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

JAXHide JAX 内容

FlaxBigBirdModel

class transformers.FlaxBigBirdModel

<来源>

( config: BigBirdConfig input_shape: Optional = 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 执行。

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。

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

此模型继承自 FlaxPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

此模型还是一个 flax.linen.Module 子类。将其用作常规的 Flax linen 模块，并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后，此模型支持 JAX 的固有特性，例如：

• 即时 (JIT) 编译

• 自动微分

• 向量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

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

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。

  什么是输入 ID？

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

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

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

  • 0 对应于一个 句子 A 标记，

  • 1 对应于一个 句子 B 标记。

  什么是标记类型 ID？

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

• head_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）-- 用于使注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]`中：

  • 1 表示头部未被遮罩，

  • 0 表示头部被遮罩。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或tuple(torch.FloatTensor)

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray）- 模型最后一层的隐藏状态序列。

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

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

  模型在每一层的输出隐藏状态以及初始嵌入输出。

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

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

FlaxBigBirdPreTrainedModel的前向方法重写了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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

< source >

( config: BigBirdConfig input_shape: Optional = 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。

  如果要更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

BigBird 模型在预训练期间顶部有两个头部：一个“掩码语言建模”头部和一个“下一个句子预测（分类）”头部。

这个模型继承自 FlaxPreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（如从 PyTorch 模型下载、保存和转换权重）。

这个模型也是一个flax.linen.Module子类。将其用作常规的 Flax 亚麻模块，并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后，这个模型支持 JAX 的固有特性，如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被“掩码”的令牌，

  • 0 表示被“掩码”的令牌。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 段令牌索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

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

• head_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 用于使注意力模块的选定头部无效的掩码。掩码值在[0, 1]`中选择：

  • 1 表示头部未被“掩码”，

  • 0 表示头部是“掩码”。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForPreTrainingOutput或tuple(torch.FloatTensor)

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

• prediction_logits（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray）—语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• seq_relationship_logits（形状为(batch_size, 2)的jnp.ndarray）—下一个序列预测（分类）头部的预测分数（SoftMax 之前的 True/False 连续性分数）。

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

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

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

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

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

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用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: Optional = 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。

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

BigBird 模型顶部带有语言建模头部（隐藏状态输出的线性层），例如用于自回归任务。

此模型继承自 FlaxPreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

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

最后，该模型支持 JAX 的固有特性，例如：

• 即时编译 (JIT)

• 自动微分

• 向量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask (numpy.ndarray of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

  • 1 用于未被掩盖的标记，

  • 0 用于被掩盖的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

• head_mask (numpy.ndarray of shape (batch_size, sequence_length), 可选) -- 用于使注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]`：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

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

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

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

  模型在每一层输出的隐藏状态以及初始嵌入输出。

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

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

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

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

• past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的jnp.ndarray元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（请参阅past_key_values输入）。

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

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用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

< source >

( config: BigBirdConfig input_shape: Optional = 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执行。

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

  如果希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

BigBird 模型顶部带有语言建模头。

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

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

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

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask (numpy.ndarray of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 [0, 1]之间：

  • 1 代表 未被掩码 的标记，

  • 0 代表 被掩码 的标记。

  什么是注意力掩码？

• token_type_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引选定在 [0, 1]之间：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

• head_mask (numpy.ndarray of shape (batch_size, sequence_length), optional) -- 用于使注意力模块中选定头部失效的掩码。掩码值选定在 [0, 1]`之间：

  • 1 表示头部 未被掩码，

  • 0 表示头部 被掩码。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 torch.FloatTensor 元组

一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False）包含根据配置（BigBirdConfig）和输入而异的各种元素。

• logits (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。

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

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

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

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

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用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: Optional = 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进行。

  请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

BigBird 模型变压器，顶部带有序列分类/回归头（顶部的线性层在汇总输出之上），例如用于 GLUE 任务。

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

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

最后，此模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 对于未掩码的标记为 1，

  • 对于掩码的标记为 0。

  什么是注意力掩码？

• 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)，可选) -- 用于使注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或tuple(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时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  每个层的模型的隐藏状态加上初始嵌入输出。

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

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

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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: Optional = 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.float32之一，jax.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 亚麻模块，并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。

最后，此模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, num_choices, sequence_length)的numpy.ndarray，可选）— 用于避免在填充令牌索引上执行注意力的蒙版。蒙版值选定在[0, 1]之间：

  • 值为 1 对应于未被 masked的令牌，

  • 对于被masked的令牌，值为 0。

  注意力蒙版是什么？

• token_type_ids（形状为(batch_size, num_choices, sequence_length)的numpy.ndarray，可选）— 指示输入的第一部分和第二部分的段标记索引。索引选定在[0, 1]之间：

  • 值为 0 对应于句子 A令牌，

  • 值为 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, num_choices, sequence_length)的numpy.ndarray，可选）— 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选定。

• head_mask（形状为(batch_size, num_choices, sequence_length)的numpy.ndarray，可选）-- 用于使注意力模块的选定头部无效的蒙版。蒙版值选定在[0, 1]之间：

  • 值为 1 表示头部未被masked，

  • 值为 0 表示头部被masked。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或tuple(torch.FloatTensor)

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

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

  分类得分（SoftMax 之前）。

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

  模型在每一层输出的隐藏状态以及初始嵌入输出。

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

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

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

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用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: Optional = 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执行。

  请注意，这只指定了计算的数据类型，不会影响模型参数的数据类型。

  如果希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

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

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

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

最后，此模型支持 JAX 的内在特性，例如：

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__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: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxTokenClassifierOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]中：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]中：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选定。

• head_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选) - 用于使注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或tuple(torch.FloatTensor)

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

• logits（形状为(batch_size, sequence_length, config.num_labels)的jnp.ndarray）- 分类分数（SoftMax 之前）。

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

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

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

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

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

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用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: Optional = 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执行。

  请注意，这只指定了计算的数据类型，不会影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

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

这个模型继承自 FlaxPreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法（例如从 PyTorch 模型下载、保存和转换权重）。

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

最后，这个模型支持 JAX 的内在特性，例如：

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__call__

<来源>

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None question_lengths = None params: dict = None dropout_rng: Optional = None indices_rng: Optional = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()以获取详细信息。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选） — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中。

  • 1 表示未屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 的标记，

  • 1 对应于 句子 B 的标记。

  什么是标记类型 ID？

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

• head_mask（形状为 (batch_size, sequence_length) 的 numpy.ndarray，可选）-- 用于使注意力模块中选定头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

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

• start_logits（形状为 (batch_size, sequence_length) 的 jnp.ndarray）— 跨度起始分数（SoftMax 之前）。

• end_logits（形状为 (batch_size, sequence_length) 的 jnp.ndarray）— 跨度结束分数（SoftMax 之前）。

• pooled_output（形状为 (batch_size, hidden_size) 的 jnp.ndarray）— FlaxBigBirdModel 返回的汇总输出。

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

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

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

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

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 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

BigBirdPegasus

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

概述

BigBird 模型是由 Zaheer, Manzil 和 Guruganesh, Guru 以及 Dubey, Kumar Avinava 和 Ainslie, Joshua 和 Alberti, Chris 和 Ontanon, Santiago 和 Pham, Philip 和 Ravula, Anirudh 和 Wang, Qifan 和 Yang, Li 等人在Big Bird: Transformers for Longer Sequences中提出的。BigBird 是一种基于稀疏注意力的 Transformer，它将 Transformer 模型（如 BERT）扩展到更长的序列。除了稀疏注意力，BigBird 还将全局注意力以及随机注意力应用于输入序列。从理论上讲，已经证明应用稀疏、全局和随机注意力可以逼近全注意力，同时对于更长的序列来说在计算上更加高效。由于具有处理更长上下文的能力，BigBird 在各种长文档 NLP 任务上表现出比 BERT 或 RoBERTa 更好的性能，如问答和摘要。

该论文的摘要如下：

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

原始代码可以在这里找到。

使用提示

• 有关 BigBird 注意力工作原理的详细解释，请参阅此博客文章。

• BigBird 有 2 种实现：original_full和block_sparse。对于序列长度<1024，建议使用original_full，因为使用block_sparse注意力没有好处。

• 目前的代码使用 3 个块和 2 个全局块的窗口大小。

• 序列长度必须能够被块大小整除。

• 当前实现仅支持ITC。

• 当前实现不支持num_random_blocks = 0。

• BigBirdPegasus 使用PegasusTokenizer。

• BigBird 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

资源

• 文本分类任务指南

• 问答任务指南

• 因果语言建模任务指南

• 翻译任务指南

• 摘要任务指南

BigBirdPegasusConfig

class transformers.BigBirdPegasusConfig

<来源>

( vocab_size = 96103 max_position_embeddings = 4096 encoder_layers = 16 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 16 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu_new' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 classifier_dropout = 0.0 scale_embedding = True pad_token_id = 0 bos_token_id = 2 eos_token_id = 1 attention_type = 'block_sparse' block_size = 64 num_random_blocks = 3 use_bias = False **kwargs )

参数

• vocab_size (int, optional, defaults to 96103) — BigBirdPegasus 模型的词汇量。定义了在调用 BigBirdPegasusModel 时可以表示的不同令牌数量。

• d_model (int, optional, defaults to 1024) — 层和池化层的维度。

• encoder_layers (int, optional, defaults to 16) — 编码器层数。

• decoder_layers (int, optional, defaults to 16) — 解码器层数。

• encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str or function, optional, defaults to "gelu_new") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有完全连接层的 dropout 概率。

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

• activation_dropout (float, optional, defaults to 0.0) — 完全连接层内激活的 dropout 比率。

• classifier_dropout (float, optional, defaults to 0.0) — 分类器的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 4096) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，1024 或 2048 或 4096）。

• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。

• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• attention_type (str, optional, defaults to "block_sparse") — 是否在编码器中使用块稀疏注意力（复杂度为 n）或原始注意力层（复杂度为 n²）。可能的值为"original_full"和"block_sparse"。

• use_bias (bool, optional, defaults to False) — 是否在查询、键、值中使用偏置。

• block_size (int, optional, defaults to 64) — 每个块的大小。仅在attention_type == "block_sparse"时有用。

• num_random_blocks (int, optional, defaults to 3) — 每个查询将关注这么多个随机块。仅在attention_type == "block_sparse"时有用。

• scale_embeddings (bool, optional, defaults to True) — 是否使用（hidden_size ** 0.5）重新缩放嵌入。

这是一个配置类，用于存储 BigBirdPegasusModel 的配置。根据指定的参数实例化一个 BigBirdPegasus 模型，定义模型架构。使用默认值实例化配置将产生类似于 BigBirdPegasus google/bigbird-pegasus-large-arxiv架构的配置。

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

示例：

>>> from transformers import BigBirdPegasusConfig, BigBirdPegasusModel

>>> # Initializing a BigBirdPegasus bigbird-pegasus-base style configuration
>>> configuration = BigBirdPegasusConfig()

>>> # Initializing a model (with random weights) from the bigbird-pegasus-base style configuration
>>> model = BigBirdPegasusModel(configuration)

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

BigBirdPegasusModel

class transformers.BigBirdPegasusModel

<来源>

( config: BigBirdPegasusConfig )

参数

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

裸的 BigBirdPegasus 模型，在顶部没有任何特定的头部输出原始隐藏状态。此模型继承自 PreTrainedModel。查看超类文档，了解库实现的所有模型的通用方法（如下载或保存，调整输入嵌入等）。

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 提供用于翻译和摘要训练的输入。默认情况下，模型将通过将input_ids向右移动来创建此张量，遵循论文。

• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果遮罩也将默认使用。

  如果要更改填充行为，您应该阅读modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• decoder_head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）- 用于在解码器中使选定的注意力模块的头部无效的掩码。掩码值选定在[0, 1]中：

  • 1 表示头部未被masked。

  • 0 表示头部被masked。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用了past_key_values，用户可以选择只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态传递给该模型的输入），而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制权来将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选）- 如果设置为True，则会返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回值

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型解码器最后一层的隐藏状态序列。

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每个层的输出的一个）。

  每个层输出的解码器的隐藏状态加上可选的初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每个层的输出的一个）。

  每个层输出的编码器的隐藏状态加上可选的初始嵌入输出。

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, BigBirdPegasusModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusModel.from_pretrained("google/bigbird-pegasus-large-arxiv")

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

>>> last_hidden_states = outputs.last_hidden_state

BigBirdPegasusForConditionalGeneration

class transformers.BigBirdPegasusForConditionalGeneration

<来源>

( config: BigBirdPegasusConfig )

参数

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

具有语言建模头部的 BigBirdPegasus 模型。可用于摘要。此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入等）。

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下，如果您提供填充标记，将会忽略填充。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 遮蔽填充标记索引上的注意力操作。遮蔽值选定在[0, 1]之间：

  • 1 表示未被遮蔽的标记，

  • 0 表示被遮蔽的标记。

  什么是注意力遮罩？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 用于翻译和摘要训练。默认情况下，模型将通过将input_ids向右移位来创建此张量，遵循论文中的方法。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果遮罩也将默认使用。

  如果您想更改填充行为，您应该阅读modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• decoder_head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）— 用于在解码器中使选定的注意力模块的头部失效的遮罩。遮罩值选定在[0, 1]之间：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成，last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回） — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。

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

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用了 past_key_values，则可以选择仅输入最后的 decoder_inputs_embeds（参见 past_key_values）。如果您想要更多控制如何将 decoder_input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果 decoder_input_ids 和 decoder_inputs_embeds 都未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

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

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（BigBirdPegasusConfig）和输入而异的各种元素。

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

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出+每一层的输出）。

  解码器在每一层的输出的隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出+每一层的输出）。

  编码器在每一层的输出的隐藏状态加上初始嵌入输出。

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

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

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

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

摘要示例：

>>> from transformers import AutoTokenizer, BigBirdPegasusForConditionalGeneration

>>> model = BigBirdPegasusForConditionalGeneration.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")

>>> ARTICLE_TO_SUMMARIZE = (
...     "The dominant sequence transduction models are based on complex recurrent or convolutional neural "
...     "networks in an encoder-decoder configuration. The best performing models also connect the encoder "
...     "and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, "
...     "based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. "
...     "Experiments on two machine translation tasks show these models to be superior in quality "
...     "while being more parallelizable and requiring significantly less time to train."
... )
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=4096, return_tensors="pt", truncation=True)

>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"], num_beams=4, max_length=15)
>>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'dominant sequence models are based on recurrent or convolutional neural networks .'

BigBirdPegasusForSequenceClassification

class transformers.BigBirdPegasusForSequenceClassification

<来源>

( config: BigBirdPegasusConfig **kwargs )

参数

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

BigBirdPegasus 模型在顶部具有序列分类/头部（在汇总输出的顶部有一个线性层），例如用于 GLUE 任务。

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

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。

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

  什么是输入 ID？

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

  • 1 表示标记未被掩盖，

  • 0 表示标记被“掩盖”。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 用于翻译和摘要训练。默认情况下，模型将通过将input_ids向右移动来创建此张量，遵循论文。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果要更改填充行为，您应该阅读modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• decoder_head_mask（形状为(num_layers, num_heads)的torch.Tensor，可选）- 用于使解码器中注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被“掩盖”。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

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

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（参见past_key_values）。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

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

• loss (torch.FloatTensor，形状为(1,)，可选，在提供label时返回) — 分类（如果config.num_labels==1则为回归）损失。

• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

单标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdPegasusForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusForSequenceClassification.from_pretrained("google/bigbird-pegasus-large-arxiv")

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

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

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = BigBirdPegasusForSequenceClassification.from_pretrained("google/bigbird-pegasus-large-arxiv", num_labels=num_labels)

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

多标签分类的示例：

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdPegasusForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusForSequenceClassification.from_pretrained("google/bigbird-pegasus-large-arxiv", 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 = BigBirdPegasusForSequenceClassification.from_pretrained(
...     "google/bigbird-pegasus-large-arxiv", 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

BigBirdPegasusForQuestionAnswering

class transformers.BigBirdPegasusForQuestionAnswering

<来源>

( config )

参数

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

BigBirdPegasus 模型在顶部具有用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的顶部添加线性层以计算span start logits和span end logits）。

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

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

forward

<来源>

( input_ids: Tensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• decoder_input_ids（torch.LongTensor，形状为(batch_size, target_sequence_length)，可选）- 用于翻译和摘要训练。默认情况下，模型将通过将input_ids向右移动来创建此张量，遵循论文。

• decoder_attention_mask（torch.LongTensor，形状为(batch_size, target_sequence_length)，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果您想要更改填充行为，您应该阅读modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• decoder_head_mask（torch.Tensor，形状为(num_layers, num_heads)，可选）- 用于在解码器中使选定的注意力模块的头部无效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的隐藏状态输出的序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码。

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

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，可以选择只输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制权来将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。

• start_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度的开始位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

• end_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度的结束位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 总跨度提取损失是起始位置和结束位置的交叉熵之和。

• start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 跨度起始得分（SoftMax 之前）。

• end_logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 跨度结束得分（SoftMax 之前）。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码。

• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。

  每层解码器的隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。

  每层编码器的隐藏状态加上初始嵌入输出。

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

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

BigBirdPegasusForQuestionAnswering 的前向方法重写了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, BigBirdPegasusForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusForQuestionAnswering.from_pretrained("google/bigbird-pegasus-large-arxiv")

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

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

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

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

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

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

BigBirdPegasusForCausalLM

class transformers.BigBirdPegasusForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]中：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用。掩码值选在[0, 1]中：

• head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于使注意力模块的选定头部失效的掩码。掩码值选在[0, 1]中：

  • 1 表示头部未被掩盖。

  • 0 表示头部被掩盖。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于使交叉注意力模块的选定头部失效的掩码。掩码值选在[0, 1]中：

  • 1 表示头部未被掩盖。

  • 0 表示头部被掩盖。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，只有在需要时才需要这两个额外的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

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

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

• use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False，则根据配置（BigBirdPegasusConfig）和输入包含各种元素。

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

• logits (torch.FloatTensor，形状为(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)。

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

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=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时返回）— torch.FloatTensor元组，长度为config.n_layers，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

示例：

>>> from transformers import AutoTokenizer, BigBirdPegasusForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusForCausalLM.from_pretrained(
...     "google/bigbird-pegasus-large-arxiv", add_cross_attention=False
... )
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits

BioGPT

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

概述

BioGPT 模型是由 Renqian Luo、Liai Sun、Yingce Xia、Tao Qin、Sheng Zhang、Hoifung Poon 和 Tie-Yan Liu 在生物文本生成和挖掘的生成预训练变压器 BioGPT中提出的。BioGPT 是一个专门用于生物医学文本生成和挖掘的领域特定生成预训练 Transformer 语言模型。BioGPT 遵循 Transformer 语言模型的骨干，并从头开始在 1500 万篇 PubMed 摘要上进行了预训练。

论文中的摘要如下：

预训练语言模型在生物医学领域引起了越来越多的关注，受到了它们在一般自然语言领域取得的巨大成功的启发。在一般语言领域的两个主要预训练语言模型分支中，即 BERT（及其变体）和 GPT（及其变体），第一个在生物医学领域得到了广泛研究，如 BioBERT 和 PubMedBERT。虽然它们在各种区分性下游生物医学任务上取得了巨大成功，但生成能力的缺乏限制了它们的应用范围。在本文中，我们提出了 BioGPT，这是一个在大规模生物医学文献上预训练的领域特定生成 Transformer 语言模型。我们在六个生物医学自然语言处理任务上评估了 BioGPT，并展示了我们的模型在大多数任务上优于先前的模型。特别是，在 BC5CDR、KD-DTI 和 DDI 端到端关系提取任务上，我们分别获得了 44.98%、38.42%和 40.76%的 F1 分数，以及在 PubMedQA 上的 78.2%的准确率，创造了一个新记录。我们对文本生成的案例研究进一步展示了 BioGPT 在生物医学文献中生成流畅描述的优势。

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

使用提示

• BioGPT 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

• BioGPT 是通过因果语言建模（CLM）目标进行训练的，因此在预测序列中的下一个标记时非常强大。利用这一特性使得 BioGPT 能够生成句法连贯的文本，正如在 run_generation.py 示例脚本中所观察到的那样。

• 该模型可以接受past_key_values（对于 PyTorch）作为输入，这是先前计算的键/值注意力对。使用这个（past_key_values 或 past）值可以防止模型在文本生成的上下文中重新计算预先计算的值。对于 PyTorch，查看 BioGptForCausalLM.forward()方法的 past_key_values 参数以获取有关其用法的更多信息。

资源

• 因果语言建模任务指南

BioGptConfig

class transformers.BioGptConfig

< source >

( vocab_size = 42384 hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 intermediate_size = 4096 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1024 initializer_range = 0.02 layer_norm_eps = 1e-12 scale_embedding = True use_cache = True layerdrop = 0.0 activation_dropout = 0.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, 可选, 默认为 42384) — BioGPT 模型的词汇大小。定义了在调用 BioGptModel 时可以表示的不同标记的数量。

• hidden_size (int, 可选, 默认为 1024) — 编码器层和池化层的维度。

• num_hidden_layers (int, 可选, 默认为 24) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, 默认为 4096) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢失概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的丢失比率。

• max_position_embeddings (int, optional, 默认为 1024) — 模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512、1024 或 2048）。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• scale_embedding (bool, optional, 默认为 True) — 通过将其除以 sqrt(d_model) 来缩放嵌入。

• use_cache (bool, optional, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。

• layerdrop (float, optional, 默认为 0.0) — 请参考关于 LayerDrop 的论文：arxiv.org/abs/1909.11556 以获取更多详细信息。

• activation_dropout (float, optional, 默认为 0.0) — 全连接层内部激活的丢失比率。

• pad_token_id (int, optional, 默认为 1) — 填充标记 ID。

• bos_token_id (int, optional, 默认为 0) — 流起始标记 ID。

• eos_token_id (int, optional, 默认为 2) — 流结束标记 ID。

这是用于存储 BioGptModel 配置的配置类。它用于根据指定的参数实例化 BioGPT 模型，定义模型架构。使用默认值实例化配置将产生与 BioGPT microsoft/biogpt 架构类似的配置。

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

示例：

>>> from transformers import BioGptModel, BioGptConfig

>>> # Initializing a BioGPT microsoft/biogpt style configuration
>>> configuration = BioGptConfig()

>>> # Initializing a model from the microsoft/biogpt style configuration
>>> model = BioGptModel(configuration)

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

BioGptTokenizer

class transformers.BioGptTokenizer

< source >

( vocab_file merges_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' pad_token = '<pad>' **kwargs )

参数

• vocab_file (str) — 词汇表文件的路径。

• merges_file (str) — 合并文件。

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

• bos_token (str, optional, 默认为 "<s>") — 在预训练期间使用的序列起始标记。可用作序列分类器标记。

  在构建使用特殊标记的序列时，这不是用于序列开头的标记。使用的标记是 cls_token。

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

  在构建使用特殊标记的序列时，这不是用于序列结尾的标记。使用的标记是 sep_token。

• sep_token（str，可选，默认为"</s>"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。

• pad_token（str，可选，默认为"<pad>"）— 用于填充的标记，例如在批处理不同长度的序列时。

构建一个 FAIRSEQ Transformer 分词器。Moses 分词后跟随字节对编码。

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

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

BioGptModel

class transformers.BioGptModel

<来源>

( config: BioGptConfig )

参数

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 1 用于未被“掩盖”的标记，

  • 0 用于被“掩盖”的标记。

  什么是注意力掩码？

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

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值）可用于加速顺序解码的内容（参见past_key_values输入）。

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

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

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

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

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

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

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中可选地如果config.is_encoder_decoder=True）可用于加速顺序解码的内容（参见past_key_values输入）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出一个，每层的输出一个）。

  每层模型的隐藏状态加上可选的初始嵌入输出。

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

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, BioGptModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/biogpt")
>>> model = BioGptModel.from_pretrained("microsoft/biogpt")

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

>>> last_hidden_states = outputs.last_hidden_state

BioGptForCausalLM

class transformers.BioGptForCausalLM

<来源>

( config )

参数

• config（~BioGptConfig](/docs/transformers/v4.37.2/en/model_doc/biogpt#transformers.BioGptConfig)） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头部的 CLM 微调的 BioGPT 模型。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

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

参数

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

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未屏蔽的标记，

  • 对于被屏蔽的标记为 0。

  什么是注意力掩码？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选） — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。

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

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。

• use_cache (bool, 可选) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（查看past_key_values）。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩码），损失仅计算在[0, ..., config.vocab_size]中的标签。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

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

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

• logits (torch.FloatTensor，形状为(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时返回）—形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

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

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, BioGptForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/biogpt")
>>> model = BioGptForCausalLM.from_pretrained("microsoft/biogpt")

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

BioGptForTokenClassification

class transformers.BioGptForTokenClassification

<来源>

( config )

参数

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

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

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

forward

<来源>

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

参数

• input_ids（形状为({0})的torch.LongTensor）—词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为({0})的torch.FloatTensor，可选）—避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码。

  • 0 表示头部被掩码。

• inputs_embeds (torch.FloatTensor，形状为({0}, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

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

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

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

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

示例：

>>> from transformers import AutoTokenizer, BioGptForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/biogpt")
>>> model = BioGptForTokenClassification.from_pretrained("microsoft/biogpt")

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

BioGptForSequenceClassification

class transformers.BioGptForSequenceClassification

< source >

( config: BioGptConfig )

参数

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

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

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

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

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

forward

< source >

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

参数

• input_ids (torch.LongTensor，形状为({0})) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• attention_mask (torch.FloatTensor，形状为({0})，optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 代表未被masked的标记。

  • 0 代表被masked的标记。

  什么是注意力掩码？

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在 [0, 1] 中：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• inputs_embeds (torch.FloatTensor，形状为 ({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回） — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。

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

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

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

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为 (batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor，形状为 (1,)，optional, 当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)） — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回） — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）

  包含预先计算的隐藏状态（自注意力块中的键和值），可以用于加速顺序解码。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出加上每一层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, BioGptForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/biogpt")
>>> model = BioGptForSequenceClassification.from_pretrained("microsoft/biogpt")

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

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

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = BioGptForSequenceClassification.from_pretrained("microsoft/biogpt", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, BioGptForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/biogpt")
>>> model = BioGptForSequenceClassification.from_pretrained("microsoft/biogpt", 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 = BioGptForSequenceClassification.from_pretrained(
...     "microsoft/biogpt", 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

Blenderbot

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/blenderbot

概述

Blender 聊天机器人模型是由 Stephen Roller、Emily Dinan、Naman Goyal、Da Ju、Mary Williamson、Yinhan Liu、Jing Xu、Myle Ott、Kurt Shuster、Eric M. Smith、Y-Lan Boureau、Jason Weston 于 2020 年 4 月 30 日提出的构建开放领域聊天机器人的配方。

该论文的摘要如下：

构建开放领域的聊天机器人是机器学习研究中具有挑战性的领域。先前的工作表明，通过增加神经模型的参数数量和训练数据的规模可以获得更好的结果，但我们展示了其他因素对于高性能聊天机器人也是重要的。良好的对话需要一些技能，一个专业的交谈者可以无缝地融合在一起：提供引人入胜的话题并倾听对话伙伴，适当展示知识、同理心和个性，同时保持一致的人设。我们展示了大规模模型可以在给定适当的训练数据和生成策略的情况下学习这些技能。我们构建了 90M、2.7B 和 9.4B 参数模型的变体，并公开提供我们的模型和代码。人类评估表明，我们最好的模型在多轮对话中的吸引力和人性度量方面优于现有方法。然后我们通过分析模型的失败案例讨论了这项工作的局限性。

这个模型是由sshleifer贡献的。作者的代码可以在这里找到。

使用提示和示例

Blenderbot 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

一个示例：

>>> from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration

>>> mname = "facebook/blenderbot-400M-distill"
>>> model = BlenderbotForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = BlenderbotTokenizer.from_pretrained(mname)
>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([UTTERANCE], return_tensors="pt")
>>> reply_ids = model.generate(**inputs)
>>> print(tokenizer.batch_decode(reply_ids))
["<s> That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?</s>"]

实现说明

• Blenderbot 使用了标准的seq2seq 模型变压器架构。

• 可用的检查点可以在model hub中找到。

• 这是默认的 Blenderbot 模型类。然而，一些较小的检查点，如facebook/blenderbot_small_90M，具有不同的架构，因此应该与 BlenderbotSmall 一起使用。

资源

• 因果语言建模任务指南

• 翻译任务指南

• 摘要任务指南

BlenderbotConfig

class transformers.BlenderbotConfig

<源代码>

( vocab_size = 8008 max_position_embeddings = 128 encoder_layers = 2 encoder_ffn_dim = 10240 encoder_attention_heads = 32 decoder_layers = 24 decoder_ffn_dim = 10240 decoder_attention_heads = 32 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 2560 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 1 scale_embedding = False pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 encoder_no_repeat_ngram_size = 3 forced_eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 50265）— Blenderbot 模型的词汇量。定义了在调用 BlenderbotModel 或 TFBlenderbotModel 时可以由inputs_ids表示的不同标记的数量。

• d_model（int，可选，默认为 1024）— 层和池化层的维度。

• encoder_layers（int，可选，默认为 12）— 编码器层的数量。

• decoder_layers（int，可选，默认为 12）— 解码器层的数量。

• encoder_attention_heads（int，可选，默认为 16）— 变压器编码器中每个注意力层的注意力头数。

• decoder_attention_heads（int，可选，默认为 16）— 变压器解码器中每个注意力层的注意力头数。

• decoder_ffn_dim（int，可选，默认为 4096）— 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int，可选，默认为 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str或function，可选，默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float，可选，默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。

• attention_dropout (float，可选，默认为 0.0) — 注意力概率的丢弃比例。

• activation_dropout (float，可选，默认为 0.0) — 全连接层内部激活的丢弃比例。

• max_position_embeddings (int，可选，默认为 128) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如 512、1024 或 2048）。

• init_std (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop (float，可选，默认为 0.0) — 编码器的 LayerDrop 概率。查看 LayerDrop paper)获取更多详细信息。

• decoder_layerdrop (float，可选，默认为 0.0) — 解码器的 LayerDrop 概率。查看 LayerDrop paper)获取更多详细信息。

• scale_embedding (bool，可选，默认为False) — 通过将 d_model 开方来缩放嵌入。

• use_cache (bool，可选，默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• forced_eos_token_id (int，可选，默认为 2) — 当达到max_length时强制作为最后生成的标记的标记 id。通常设置为eos_token_id。

这是用于存储 BlenderbotModel 配置的配置类。它用于根据指定的参数实例化 Blenderbot 模型，定义模型架构。使用默认值实例化配置将产生类似于 Blenderbot facebook/blenderbot-3B架构的配置。

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

示例：

>>> from transformers import BlenderbotConfig, BlenderbotModel

>>> # Initializing a Blenderbot facebook/blenderbot-3B style configuration
>>> configuration = BlenderbotConfig()

>>> # Initializing a model (with random weights) from the facebook/blenderbot-3B style configuration
>>> model = BlenderbotModel(configuration)

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

BlenderbotTokenizer

class transformers.BlenderbotTokenizer

< source >

( 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) — 合并文件的路径。

• 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）—是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（Blenderbot 分词器通过前面的空格检测单词的开头）。

构建一个 Blenderbot 分词器，从 GPT-2 分词器派生，使用字节级字节对编码。

此分词器已经训练成将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

无论是在句子开头（没有空格）还是其他位置，都可以以不同方式编码：

>>> from transformers import BlenderbotTokenizer

>>> tokenizer = BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B")
>>> tokenizer.add_prefix_space = False
>>> tokenizer("Hello world")["input_ids"]
[47, 921, 86, 1085, 2]

>>> tokenizer(" Hello world")["input_ids"]
[6950, 1085, 2]

您可以通过在实例化此分词器时或在对某些文本调用它时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，此分词器将在每个单词之前添加一个空格（甚至是第一个单词）。

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

build_inputs_with_special_tokens

<来源>

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

参数

• token_ids_0（List[int]）—要添加特殊标记的 ID 列表

• token_ids_1（List[int]，可选）—将被忽略

返回

List[int]

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

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

• 单个序列：X </s>

BlenderbotTokenizerFast

class transformers.BlenderbotTokenizerFast

<来源>

( 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）—合并文件的路径。

• 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）—是否将初始空格添加到输入。这允许将前导单词视为任何其他单词。（Blenderbot 标记器通过前面的空格检测单词的开头）。

• trim_offsets（bool，可选，默认为True）—后处理步骤是否应修剪偏移量以避免包含空格。

构建一个“快速”Blenderbot 标记器（由 HuggingFace 的tokenizers库支持），派生自 GPT-2 标记器，使用字节级字节对编码。

此标记器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），因此一个词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

>>> from transformers import BlenderbotTokenizerFast

>>> tokenizer = BlenderbotTokenizerFast.from_pretrained("facebook/blenderbot-3B")
>>> tokenizer("Hello world")["input_ids"]
[6950, 1085, 2]

>>> tokenizer(" Hello world")["input_ids"]
[6950, 1085, 2]

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

当与is_split_into_words=True一起使用时，此标记器需要使用add_prefix_space=True进行实例化。

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

build_inputs_with_special_tokens

<来源>

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

参数

• token_ids_0（List[int]）—要添加特殊标记的 ID 列表

• token_ids_1（List[int]，可选）—将被忽略

返回

List[int]

包含适当特殊标记的 input IDs 列表。

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

• 单个序列：X </s>

Pytorch 隐藏了 Pytorch 内容

BlenderbotModel

有关forward和generate的参数，请参阅 BartModel

class transformers.BlenderbotModel

<来源>

( config: BlenderbotConfig )

参数

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

裸的 Blenderbot 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

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

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Union = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免对填充标记索引执行注意力的掩码。掩码值选定在 [0, 1] 范围内：

  • 对于未被掩码的标记为 1，

  • 对于被掩码的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  Blenderbot 使用 bos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，可选择只输入最后的 decoder_input_ids（参见 past_key_values）。

• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。

• head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选定在 [0, 1] 范围内：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于将解码器中注意力模块的选定头部置零的掩码。掩码值选定在 [0, 1] 范围内：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，optional) — 用于在解码器中的交叉注意力模块中使选定头部失效的掩码。掩码值选定在 [0, 1]：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成，last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。

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

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用了 past_key_values，则只需输入最后的 decoder_inputs_embeds（参见 past_key_values）。如果您想要更多控制如何将 decoder_input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

  如果 decoder_input_ids 和 decoder_inputs_embeds 都未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

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

• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。

  如果使用 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层的输出一个）。

  每层解码器的隐藏状态以及可选的初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层的输出一个）。

  每层编码器的隐藏状态以及可选的初始嵌入输出。

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

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

BlenderbotModel 的前向方法重写了 __call__ 特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, BlenderbotModel

>>> model = BlenderbotModel.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_input_ids)

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

BlenderbotForConditionalGeneration

有关 forward 和 generate 的参数，请参阅 BartForConditionalGeneration。

class transformers.BlenderbotForConditionalGeneration

<来源>

( config: BlenderbotConfig )

参数

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

带有语言建模头的 Blenderbot 模型。可用于摘要。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Union = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示标记未被masked，

  • 对于被masked的标记为 0。

  注意掩码是什么？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。

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

  解码器输入 ID 是什么？

  Blenderbot 使用bos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于在解码器中的交叉注意力模块中使选定头部失效的掩码。掩码值选在[0, 1]中：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）- 元组由(last_hidden_state，可选：hidden_states，可选：attentions)组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

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

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可能只需输入最后的decoder_inputs_embeds（请参见past_key_values）。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 语言建模损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出和每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

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

• cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

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

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出和每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

对话示例：

>>> from transformers import AutoTokenizer, BlenderbotForConditionalGeneration

>>> mname = "facebook/blenderbot-400M-distill"
>>> model = BlenderbotForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> print("Human: ", UTTERANCE)
Human:  My friends are cool but they eat too many carbs.

>>> inputs = tokenizer([UTTERANCE], return_tensors="pt")
>>> reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0])
Bot: That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?

>>> REPLY = "I'm not sure"
>>> print("Human: ", REPLY)
Human: I'm not sure

>>> NEXT_UTTERANCE = (
...     "My friends are cool but they eat too many carbs.</s> <s>That's unfortunate. "
...     "Are they trying to lose weight or are they just trying to be healthier?</s> "
...     "<s> I'm not sure."
... )
>>> inputs = tokenizer([NEXT_UTTERANCE], return_tensors="pt")
>>> next_reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(next_reply_ids, skip_special_tokens=True)[0])
Bot:   I see. Well, it's good that they're trying to change their eating habits.

BlenderbotForCausalLM

class transformers.BlenderbotForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下会忽略填充。

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

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力。掩码值选定在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选定在[0, 1]之间：

• head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), 可选) — 用于使注意力模块中选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块中选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，需要这两个额外的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码。

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

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

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

  • 对于未被掩码的标记为1，

  • 对于被掩码的标记为0。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

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

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 + 每一层的输出）。

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

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

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

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

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

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

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

示例：

>>> from transformers import AutoTokenizer, BlenderbotForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")
>>> model = BlenderbotForCausalLM.from_pretrained("facebook/blenderbot-400M-distill", add_cross_attention=False)
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
True

TensorFlow 隐藏 TensorFlow 内容

TFBlenderbotModel

class transformers.TFBlenderbotModel

< source >

( config: BlenderbotConfig *inputs **kwargs )

参数

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

裸的 BLENDERBOT 模型，输出原始隐藏状态，没有特定的顶部头。此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

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

• 一个只有 input_ids 的单个张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

< source >

( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: List[tf.Tensor] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

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

  • 对于“未屏蔽”的标记为 1，

  • 对于“屏蔽”的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (tf.Tensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

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

  解码器输入 ID 是什么？

  Blenderbot 使用bos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 默认情况下将被创建并忽略填充标记。不建议为大多数用例设置此参数。

• decoder_position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）— 用于使编码器中选择的头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于使解码器中选择的头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于使交叉注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• encoder_outputs（tf.FloatTensor，可选）— 编码器最后一层的隐藏状态。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列

• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)而不是所有decoder_input_ids的形状为(batch_size, sequence_length)。

• use_cache（bool，可选，默认为True）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包括各种元素，取决于配置（BlenderbotConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）- 模型解码器最后一层的隐藏状态序列输出。

  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

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

  包含解码器的预计算隐藏状态（注意力块中的键和值），可以用于加速顺序解码。

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

  解码器每层输出的隐藏状态加上初始嵌入输出。

• decoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

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

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

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

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 模型编码器最后一层的隐藏状态序列输出。

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

  编码器每层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

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

TFBlenderbotModel 的前向方法重写了__call__特殊方法。

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")
>>> model = TFBlenderbotModel.from_pretrained("facebook/blenderbot-400M-distill")

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

>>> last_hidden_states = outputs.last_hidden_state

TFBlenderbotForConditionalGeneration

class transformers.TFBlenderbotForConditionalGeneration

<来源>

( config *inputs **kwargs )

参数

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

具有语言建模头的 BLENDERBOT 模型。可用于摘要。该模型继承自 TFPreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

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

• 只有一个input_ids的张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: List[tf.Tensor] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• input_ids（形状为({0})的tf.Tensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为({0})的tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  Blenderbot 使用bos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，可以选择只输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 将默认生成并忽略填充标记。不建议为大多数用例设置此选项。

• decoder_position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选）- 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）- 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使交叉注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• encoder_outputs（tf.FloatTensor，可选）- 编码器最后一层的输出的隐藏状态。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列

• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用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。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）- 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或者 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或者 tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或者一个 tf.Tensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False）包含不同元素，取决于配置（BlenderbotConfig）和输入。

• loss (tf.Tensor of shape (n,), optional, 其中 n 是非掩码标签的数量，当提供 labels 时返回) — 语言建模损失。

• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 前每个词汇标记的分数）。

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

  包含解码器的预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码（参见 past_key_values 输入）。

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

  每层解码器的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=True 或者 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

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

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

• encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。

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

  每层编码器的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=True 或者 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

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

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

对话示例：

>>> from transformers import AutoTokenizer, TFBlenderbotForConditionalGeneration

>>> mname = "facebook/blenderbot-400M-distill"
>>> model = TFBlenderbotForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> print("Human: ", UTTERANCE)

>>> inputs = tokenizer([UTTERANCE], return_tensors="tf")
>>> reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0])

>>> REPLY = "I'm not sure"
>>> print("Human: ", REPLY)
>>> NEXT_UTTERANCE = (
...     "My friends are cool but they eat too many carbs.</s> <s>That's unfortunate. "
...     "Are they trying to lose weight or are they just trying to be healthier?</s> "
...     "<s> I'm not sure."
... )
>>> inputs = tokenizer([NEXT_UTTERANCE], return_tensors="tf")
>>> next_reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(next_reply_ids, skip_special_tokens=True)[0])

JAXHide JAX 内容

FlaxBlenderbotModel

class transformers.FlaxBlenderbotModel

<来源>

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

参数

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

裸 MBart 模型变压器输出原始隐藏状态，没有特定的头部。此模型继承自 FlaxPreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

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

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

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）- 词汇表中输入序列令牌的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 避免在填充令牌索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 用于“未屏蔽”标记的令牌，

  • 0 用于“屏蔽”标记的令牌。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）- 解码器输入序列令牌的索引。

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

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果没有提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。

• decoder_attention_mask (jnp.ndarray，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

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

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或tuple(torch.FloatTensor)

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

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

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。

• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

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

  解码器在每一层的输出隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

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

  编码器在每层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxBlenderbotModel

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")
>>> model = FlaxBlenderbotModel.from_pretrained("facebook/blenderbot-400M-distill")

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

>>> last_hidden_states = outputs.last_hidden_state

encode

<来源>

( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (jnp.ndarray，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask (jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]：

  • 对于未掩码的标记为 1，

  • 对于掩码的标记为 0。

  什么是注意力掩码？

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

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括各种元素，取决于配置（<class 'transformers.models.blenderbot.configuration_blenderbot.BlenderbotConfig'>）和输入。

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxBlenderbotForConditionalGeneration

>>> model = FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)

解码

<来源>

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray）— 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。

• encoder_outputs（tuple(tuple(jnp.ndarray)) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• encoder_attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 对于未被掩码的标记为 1。

  • 对于被掩码的标记为 0。

  什么是注意力掩码？

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• decoder_position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

• past_key_values（Dict[str, np.ndarray]，可选，由init_cache返回或传递先前的past_key_values时返回）— 预先计算的隐藏状态的字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或tuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或传递config.return_dict=False）包括根据配置（<class 'transformers.models.blenderbot.configuration_blenderbot.BlenderbotConfig'>）和输入的不同元素。

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

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或传递config.use_cache=True时返回）— 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True，还有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中，如果config.is_encoder_decoder=True，还可以使用）可用于加速顺序解码（请参见past_key_values输入）。

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

  模型在每个层的输出以及初始嵌入输出的隐藏状态。

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

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

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

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

示例：

>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxBlenderbotForConditionalGeneration

>>> model = FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> last_decoder_hidden_states = outputs.last_hidden_state

FlaxBlenderbotForConditionalGeneration

class transformers.FlaxBlenderbotForConditionalGeneration

<来源>

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

参数

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

具有语言建模头的 Blenderbot 模型。可用于摘要。此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

最后，此模型支持 JAX 的内在特性，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 对于未被“masked”掉的标记为 1，

  • 对于被masked掉的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  如果您想要更改填充行为，您应该根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

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

• decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 解码器每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

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

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

• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

• decoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  解码器每层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

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

  编码器每一层的隐藏状态以及初始嵌入输出。

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

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

FlaxBlenderbotPreTrainedModel的前向方法重写了__call__特殊方法。

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

对话示例::

>>> from transformers import AutoTokenizer, FlaxBlenderbotForConditionalGeneration

>>> model = FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([UTTERANCE], max_length=1024, return_tensors="np")

>>> # Generate Reply
>>> reply_ids = model.generate(inputs["input_ids"], num_beams=4, max_length=5, early_stopping=True).sequences
>>> print([tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=False) for g in reply_ids])

encode

< source >

( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (jnp.ndarray，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask (jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]范围内：

  • 对于未被masked的标记为 1。

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.blenderbot.configuration_blenderbot.BlenderbotConfig'>）和输入不同元素。

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxBlenderbotForConditionalGeneration

>>> model = FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)

解码

<来源>

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• decoder_input_ids (jnp.ndarray，形状为(batch_size, target_sequence_length)) — 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，用于去噪预训练，遵循论文。

• encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组包括(last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• encoder_attention_mask (jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的蒙版。蒙版值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力蒙版？

• decoder_attention_mask (jnp.ndarray，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果蒙版也将默认使用。

  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

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

• past_key_values (Dict[str, np.ndarray], 可选, 由init_cache返回或传递先前past_key_values时返回) — 预先计算的隐藏状态的字典（在注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（<class 'transformers.models.blenderbot.configuration_blenderbot.BlenderbotConfig'>）和输入的不同元素。

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

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

  模型在每一层输出的隐藏状态以及初始嵌入输出。

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

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

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

  在注意力 SoftMax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。

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

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。

示例：

>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxBlenderbotForConditionalGeneration

>>> model = FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-400M-distill")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="jax")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits