Transformers 文档
BigBirdPegasus
并获得增强的文档体验
开始使用
此模型于 2020-07-28 发布，并于 2021-05-07 添加到 Hugging Face Transformers。
BigBirdPegasus
BigBirdPegasus 是一种用于长输入摘要的编码器-解码器（序列到序列）Transformer 模型。它扩展了 BigBird 架构，并借鉴了 Pegasus 中的额外预训练目标，称为间隙序列生成（gap sequence generation，GSG）。通过掩盖整个句子，模型必须填充文档中的间隙。BigBirdPegasus 能够跟踪长上下文，使其在总结冗长输入方面表现出色，超越了基础 Pegasus 模型的性能。
您可以在 Google 组织下找到所有原始 BigBirdPegasus 检查点。
此模型由 vasudevgupta 贡献。
点击右侧边栏中的 BigBirdPegasus 模型，了解如何将 BigBirdPegasus 应用于不同语言任务的更多示例。
下面的示例演示了如何使用 Pipeline、AutoModel 和命令行来总结文本。
import torch
from transformers import pipeline
pipeline = pipeline(
task="summarization",
model="google/bigbird-pegasus-large-arxiv",
dtype=torch.float32,
device=0
)
pipeline("""Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle.""")量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
以下示例使用 bitsandbytes 将权重仅量化为 int4。
import torch
from transformers import BitsAndBytesConfig, AutoModelForSeq2SeqLM, AutoTokenizer
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"google/bigbird-pegasus-large-arxiv",
dtype=torch.bfloat16,
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained(
"google/bigbird-pegasus-large-arxiv"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))注意事项
- BigBirdPegasus 还使用 PegasusTokenizer。
- 输入应在右侧进行填充，因为 BigBird 使用绝对位置嵌入。
- BigBirdPegasus 支持
original_full和block_sparse注意力。如果输入序列长度小于 1024，建议使用original_full，因为对于较小的输入，稀疏模式不会带来太多好处。 - 当前的实现使用 3 个块的窗口大小和 2 个全局块，只支持 ITC 实现，不支持
num_random_blocks=0。 - 序列长度必须能被块大小整除。
资源
阅读 Understanding BigBird’s Block Sparse Attention 博客文章，了解有关 BigBird 注意力如何工作的更多详细信息。
BigBirdPegasusConfig
class transformers.BigBirdPegasusConfig
< source >( 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 is_decoder = False tie_word_embeddings = True **kwargs )
参数
- vocab_size (
int, optional, defaults to 96103) — BigBirdPegasus 模型的词汇表大小。定义了调用 BigBirdPegasusModel 时传入的inputs_ids可以表示的不同 token 数量。 - 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 (
strorfunction, 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 论文](参见 https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, optional, defaults toTrue) — 模型是否应返回最后一个 key/value 注意力（并非所有模型都使用）。 - attention_type (
str, optional, defaults to"block_sparse") — 是否使用论文中引入的块稀疏注意力（复杂度为 n）或编码器中原始注意力层（复杂度为 n^2）。可能的值为"original_full"和"block_sparse"。 - use_bias (
bool, optional, defaults toFalse) — 是否在查询、键、值中使用偏置。 - 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 toTrue) — 是否使用 (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.configBigBirdPegasusModel
class transformers.BigBirdPegasusModel
< source >( config: BigBirdPegasusConfig )
参数
- config (BigBirdPegasusConfig) — 模型配置类，包含模型的所有参数。使用配置文件实例化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
裸 Bigbird Pegasus 模型，输出原始隐藏状态，顶部没有特定头部。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: list[torch.FloatTensor] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.LongTensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 输入序列中词汇表的标记索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值选择在[0, 1]中：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 为翻译和摘要训练提供。默认情况下，模型将根据论文中的说明，通过将input_ids向右移动来创建此张量。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也将使用因果掩码。如果要更改填充行为，应阅读
modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - encoder_outputs (
list, optional) — 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）形状为(batch_size, sequence_length, hidden_size)的last_hidden_state，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values，当use_cache=True或config.use_cache=True时使用。仅允许 Cache 实例作为输入，请参阅我们的 kv cache guide。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与作为输入馈入的缓存格式相同的缓存格式。
如果使用
past_key_values，则用户应仅输入形状为(batch_size, unprocessed_length)的未处理input_ids（即没有向此模型提供过去键值状态的标记），而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这将很有用。 - decoder_inputs_embeds (
torch.FloatTensorof 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 而不是普通的元组。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 表示输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (BigBirdPegasusConfig) 和输入的不同元素。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
BigBirdPegasusModel 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
BigBirdPegasusForConditionalGeneration
class transformers.BigBirdPegasusForConditionalGeneration
< source >( config: BigBirdPegasusConfig )
参数
- config (BigBirdPegasusConfig) — 模型配置类，包含模型的所有参数。使用配置文件实例化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有语言建模头部的 BigBirdPegasus 模型。可用于摘要。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: list[torch.FloatTensor] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.LongTensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 输入序列中词汇表的标记索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值选择在[0, 1]中：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 为翻译和摘要训练提供。默认情况下，模型将根据论文中的说明，通过将input_ids向右移动来创建此张量。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也将使用因果掩码。如果要更改填充行为，应阅读
modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - encoder_outputs (
list, optional) — 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）形状为(batch_size, sequence_length, hidden_size)的last_hidden_state，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的past_key_values，当use_cache=True或config.use_cache=True时使用。仅允许 Cache 实例作为输入，请参阅我们的 kv cache guide。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与作为输入馈入的缓存格式相同的缓存格式。
如果使用
past_key_values，则用户应仅输入形状为(batch_size, unprocessed_length)的未处理input_ids（即没有向此模型提供过去键值状态的标记），而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这将很有用。 - decoder_inputs_embeds (
torch.FloatTensorof 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的值。 - labels (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。 - 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 而不是普通的元组。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 表示输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (BigBirdPegasusConfig) 和输入的不同元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
BigBirdPegasusForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
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
< source >( config: BigBirdPegasusConfig **kwargs )
参数
- config (BigBirdPegasusConfig) — 模型配置类，包含模型的所有参数。使用配置文件实例化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有序列分类/头部的 BigBirdPegasus 模型（池化输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: list[torch.FloatTensor] | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.LongTensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 输入序列中词汇表的标记索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值选择在[0, 1]中：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 为翻译和摘要训练提供。默认情况下，模型将根据论文中的说明，通过将input_ids向右移动来创建此张量。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也会使用因果掩码（Causal mask）。如果您想更改填充行为，应阅读
modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - encoder_outputs (
list, optional) — 元组包含（last_hidden_state, *可选：hidden_states, *可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，*可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力中。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - decoder_inputs_embeds (
torch.FloatTensorof 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的值。 - labels (
torch.LongTensorof shape(batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。 - 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 对象而不是普通的元组。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 描述输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 对象或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置（BigBirdPegasusConfig）和输入的不同元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供label时返回) — 分类 (如果 config.num_labels==1 则为回归) 损失。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
BigBirdPegasusForSequenceClassification 的 forward 方法，它重写了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
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()
>>> model.config.id2label[predicted_class_id]
...
>>> # 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
>>> round(loss.item(), 2)
...多标签分类示例
>>> 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).lossBigBirdPegasusForQuestionAnswering
class transformers.BigBirdPegasusForQuestionAnswering
< source >( config model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )
参数
- config (BigBirdPegasusForQuestionAnswering) — 模型的配置类，包含模型的所有参数。使用配置文件初始化模型不会加载与模型相关的权重，只会加载配置。要加载模型权重，请查看 from_pretrained() 方法。
带有跨度分类头（span classification head）的 Bigbird Pegasus transformer，用于提取式问答任务，例如 SQuAD（在隐藏状态输出之上添加一个线性层来计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: list[torch.FloatTensor] | None = None start_positions: torch.LongTensor | None = None end_positions: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.LongTensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- decoder_input_ids (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 为翻译和摘要训练提供。默认情况下，模型将根据论文中的内容通过将input_ids向右移位来创建此张量。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也会使用因果掩码（Causal mask）。如果您想更改填充行为，应阅读
modeling_bigbird_pegasus._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - encoder_outputs (
list, optional) — 元组包含（last_hidden_state, *可选：hidden_states, *可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，*可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力中。 - start_positions (
torch.LongTensorof shape(batch_size,), optional) — 用于计算标记分类损失的标注跨度起始位置（索引）的标签。位置将被限制在序列长度（sequence_length）范围内。序列以外的位置不计入损失计算。 - end_positions (
torch.LongTensorof shape(batch_size,), optional) — 用于计算标记分类损失的标注跨度结束位置（索引）的标签。位置将被限制在序列长度（sequence_length）范围内。序列以外的位置不计入损失计算。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - decoder_inputs_embeds (
torch.FloatTensorof 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 对象而不是普通的元组。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 描述输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 对象或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置（BigBirdPegasusConfig）和输入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围结束分数（SoftMax 之前）。 -
past_key_values (
EncoderDecoderCache, optional, 当传入use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
BigBirdPegasusForQuestionAnswering 的 forward 方法，它重写了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...BigBirdPegasusForCausalLM
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None encoder_hidden_states: torch.FloatTensor | None = None encoder_attention_mask: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.LongTensor | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- encoder_hidden_states (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。 - encoder_attention_mask (
torch.FloatTensorof shape(batch_size, sequence_length), optional) — 用于避免在编码器输入填充标记索引上执行注意力的掩码。如果模型被配置为解码器，则此掩码用于交叉注意力。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- past_key_values (
~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速顺序解码。当use_cache=True或config.use_cache=True时，这通常包括模型在解码上一阶段返回的past_key_values。只允许 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果没有传入
past_key_values，默认将初始化 DynamicCache。模型将输出与输入时相同的缓存格式。
如果使用了
past_key_values，则期望用户只输入形状为(batch_size, unprocessed_length)的未处理input_ids（即没有向模型提供其过去键值状态的标记），而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]范围内或为 -100（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），仅对标签在[0, ..., config.vocab_size]范围内的标记计算损失。 - 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 对象而不是普通的元组。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 描述输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。 - logits_to_keep (
Union[int, torch.Tensor], optional, defaults to0) — 如果为int，则计算最后logits_to_keep个标记的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成时只需要最后一个标记的 logits，并且仅计算该标记的 logits可以节省内存，这对于长序列或大词汇量来说非常重要。如果为torch.Tensor，则必须是一维张量，对应于在序列长度维度中保留的索引。这在使用打包张量格式（batch 和 sequence length 在单个维度中）时很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 对象或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置（BigBirdPegasusConfig）和输入的不同元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。
-
past_key_values (
Cache, optional, 当传递use_cache=True或当config.use_cache=True时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。
The BigBirdPegasusForCausalLM forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, BigBirdPegasusForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")
>>> model = BigBirdPegasusForCausalLM.from_pretrained(
... "google/bigbird-pegasus-large-arxiv"
... )
>>> 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