Transformers 4.37 中文文档（五十一）（1）

PEGASUS-X

概述

PEGASUS-X 模型由 Jason Phang、Yao Zhao 和 Peter J. Liu 在 Investigating Efficiently Extending Transformers for Long Input Summarization 中提出。

PEGASUS-X（PEGASUS eXtended）通过额外的长输入预训练和在编码器中使用交错的块局部注意力与全局标记，扩展了 PEGASUS 模型，用于长输入摘要。

该论文的摘要如下：

尽管大型预训练 Transformer  模型已被证明在处理自然语言任务方面非常有能力，但处理长序列输入仍然是一个重大挑战。其中一个任务是长输入摘要，其中输入长于大多数预训练模型的最大输入上下文。通过一系列广泛的实验，我们研究了哪些模型架构变化和预训练范式可以最有效地使预训练的  Transformer 适应长输入摘要。我们发现，具有全局编码器标记的交错块局部 Transformer  取得了性能和效率的良好平衡，并且在长序列上进行额外的预训练阶段可以有意义地提高下游摘要性能。基于我们的发现，我们介绍了 PEGASUS-X，这是  PEGASUS 模型的扩展，具有额外的长输入预训练，以处理长达 16K 个标记的输入。PEGASUS-X  在长输入摘要任务上取得了强大的性能，与更大的模型相当，同时增加了少量额外参数，并且不需要模型并行训练。

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

文档资源

• 翻译任务指南
  
• 摘要任务指南
  

PEGASUS-X 使用与 PEGASUS 相同的分词器。

PegasusXConfig

class transformers.PegasusXConfig

< source >

( vocab_size = 96103 max_position_embeddings = 16384 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' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 0 scale_embedding = True pad_token_id = 0 eos_token_id = 1 forced_eos_token_id = 1 num_global_tokens = 32 block_size = 512 stagger_local_blocks = True **kwargs )

参数

• vocab_size (int, optional, defaults to 96103) — PEGASUS-X 模型的词汇大小。定义了在调用 PegasusXModel 时可以表示的不同标记数量。
  
• 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") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。
  
• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
  
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。
  
• activation_dropout（float，可选，默认为 0.0）— 全连接层内激活的丢弃比率。
  
• max_position_embeddings（int，可选，默认为 16384）— 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。
  
• init_std（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• encoder_layerdrop（float，可选，默认为 0.0）— 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。
  
• decoder_layerdrop（float，可选，默认为 0.0）— 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。
  
• use_cache（bool，可选，默认为True）— 模型是否应返回最后的键/值注意力（并非所有模型都使用）
  
• forced_eos_token_id（int，可选，默认为 1）— 当达到max_length时，强制作为最后生成的标记的标记 id。通常设置为eos_token_id。
  
• num_global_tokens（int，可选，默认为 128）— 用于编码器的全局标记数
  
• block_size（int，可选，默认为 512）— 编码器局部注意力的块大小。序列长度应该是块大小的精确倍数。如果stagger_local_block为 True，则block_size必须是 2 的倍数。
  
• stagger_local_block（bool，可选，默认为True）— 是否将每个其他局部注意力错开半个块
  

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

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

示例：

>>> from transformers import PegasusXConfig, PegasusXModel
>>> # Initializing a PEGASUS google/pegasus-x-large style configuration
>>> configuration = PegasusXConfig()
>>> # Initializing a model (with random weights) from the google/pegasus-x-large style configuration
>>> model = PegasusXModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

PegasusXModel

class transformers.PegasusXModel

<来源>

( config: PegasusXConfig )

参数

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

PEGASUS-X 模型裸输出原始隐藏状态，没有特定的头部。这个模型继承自 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 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)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.
  Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
  What are input IDs?
  
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation.
  
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

• 1 for tokens that are not masked,
  
• 0 for tokens that are masked.
  

• What are attention masks?
  
• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — Indices of decoder input sequence tokens in the vocabulary.
  Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
  What are decoder input IDs?
  PEGASUS-X uses the pad_token_id as the starting token for decoder_input_ids generation. If past_key_values is used, optionally only the last decoder_input_ids have to be input (see past_key_values).
  
• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — Default behavior: generate a tensor that ignores pad tokens in decoder_input_ids. Causal mask will also be used by default.
  
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — Tuple consists of (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state of shape (batch_size, sequence_length, hidden_size), optional) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
  
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — Tuple of tuple(torch.FloatTensor) of length config.n_layers, with each tuple having 2 tensors of shape (batch_size, num_heads, sequence_length, embed_size_per_head)) and 2 additional tensors of shape (batch_size, num_heads, encoder_sequence_length, embed_size_per_head).
  Contains  pre-computed hidden-states (key and values in the self-attention blocks  and in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.
  If past_key_values are used, the user can optionally input only the last decoder_input_ids (those that don’t have their past key value states given to this model) of shape (batch_size, 1) instead of all decoder_input_ids of shape (batch_size, sequence_length).
  
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.
  
• 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 而不是普通元组。
  

返回

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

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出的隐藏状态序列。
  如果使用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 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例:

>>> from transformers import AutoTokenizer, PegasusModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-x-large")
>>> model = PegasusModel.from_pretrained("google/pegasus-x-large")
>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_inputs = tokenizer("Studies show that", return_tensors="pt")
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_inputs.input_ids)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 4, 1024]

PegasusXForConditionalGeneration

class transformers.PegasusXForConditionalGeneration

<来源>

( config: PegasusXConfig )

参数

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

PEGASUS-X 用于条件生成（例如总结）。该模型继承自 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 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？
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选择直接传递嵌入表示，而不是传递input_ids。
  
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

• 对于“未被掩码”的标记为 1，
  
• 对于被“掩码”的标记为 0。
  

• 什么是注意力掩码？
  
• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是解码器输入 ID？
  PEGASUS-X 使用pad_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中填充标记的张量。因果掩码也将默认使用。
  
• 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，用户可以选择仅输入最后一个形状为(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，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, 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 时），包含根据配置（PegasusXConfig）和输入的各种元素。

• loss (torch.FloatTensor，形状为 (1,)，optional，当提供 labels 时返回) — 语言建模损失。
  
• logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (tuple(tuple(torch.FloatTensor))，optional，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 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 时返回) — 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（形状为(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 之后，用于计算自注意力头中的加权平均值。
  

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

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

摘要示例：

>>> from transformers import AutoTokenizer, PegasusXForConditionalGeneration
>>> model = PegasusXForConditionalGeneration.from_pretrained("google/pegasus-x-base")
>>> tokenizer = AutoTokenizer.from_pretrained("google/pegasus-x-large")
>>> ARTICLE_TO_SUMMARIZE = (
...     "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
...     "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
...     "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer(ARTICLE_TO_SUMMARIZE, max_length=1024, return_tensors="pt")
>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"])
>>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"California's largest electricity provider has turned off power to hundreds of thousands of customers."

Transformers 4.37 中文文档（五十一）（2）https://developer.aliyun.com/article/1565776