Transformers 4.37 中文文档（九十九）（3）

Transformers 4.37 中文文档（九十九）（2）https://developer.aliyun.com/article/1564042

SpecialTokensMixin

class transformers.SpecialTokensMixin

<来源>

( verbose = False **kwargs )

参数

• bos_token（str或tokenizers.AddedToken，可选）— 代表句子开头的特殊标记。
  
• eos_token（str或tokenizers.AddedToken，可选）— 代表句子结尾的特殊标记。
  
• unk_token（str或tokenizers.AddedToken，可选）— 代表一个未知词的特殊标记。
  
• sep_token（str或tokenizers.AddedToken，可选）— 代表同一输入中两个不同句子之间的特殊标记（例如 BERT 使用）。
  
• pad_token（str或tokenizers.AddedToken，可选）— 用于使标记数组大小相同以进行批处理的特殊标记。然后将被注意机制或损失计算忽略。
  
• cls_token（str或tokenizers.AddedToken，可选）— 代表输入类别的特殊标记（例如 BERT 使用）。
  
• mask_token（str或tokenizers.AddedToken，可选）— 代表被屏蔽的标记的特殊标记（例如 BERT 使用）。
  
• additional_special_tokens（元组或str或tokenizers.AddedToken的列表，可选）— 一组额外的标记，将被标记为special，这意味着如果skip_special_tokens设置为True，在解码时将被跳过。
  

由 PreTrainedTokenizer 和 PreTrainedTokenizerFast 派生的 mixin，用于处理与特殊标记相关的特定行为。特别是，这个类保存了可以用于以与模型无关的方式直接访问这些特殊标记的属性，并允许设置和更新特殊标记。

add_special_tokens

<来源>

( special_tokens_dict: Dict replace_additional_special_tokens = True ) → export const metadata = 'undefined';int

参数

• special_tokens_dict（字典str到str或tokenizers.AddedToken）— 键应该在预定义特殊属性列表中：[bos_token、eos_token、unk_token、sep_token、pad_token、cls_token、mask_token、additional_special_tokens]。
  仅当它们不在词汇表中时才会添加标记（通过检查分词器是否将unk_token的索引分配给它们进行测试）。
  
• replace_additional_special_tokens（bool，可选，默认为True） - 如果为True，则现有的额外特殊标记列表将被special_tokens_dict中提供的列表替换。否则，self._additional_special_tokens只是被扩展。在前一种情况下，这些标记不会从标记器的完整词汇表中删除 - 它们只被标记为非特殊标记。请记住，这只影响解码时跳过哪些标记，而不影响added_tokens_encoder和added_tokens_decoder。这意味着以前的additional_special_tokens仍然是添加的标记，并且不会被模型分割。
  

返回

int

将特殊标记添加到词汇表中的数量。

将特殊标记的字典（eos、pad、cls 等）添加到编码器中，并将它们链接到类属性。如果特殊标记不在词汇表中，则将它们添加到词汇表中（从当前词汇表的最后索引开始索引）。

在向词汇表中添加新标记时，您应确保还调整模型的标记嵌入矩阵，以使其嵌入矩阵与标记器匹配。

为了实现这一点，请使用 resize_token_embeddings()方法。

使用add_special_tokens将确保您的特殊标记可以以多种方式使用：

• 在解码时可以跳过特殊标记，使用skip_special_tokens = True。
  
• 特殊标记由标记器仔细处理（它们永远不会被分割），类似于AddedTokens。
  
• 您可以使用标记器类属性轻松引用特殊标记，如tokenizer.cls_token。这使得开发与模型无关的训练和微调脚本变得容易。
  

在可能的情况下，为提供的预训练模型已经注册了特殊标记（例如 BertTokenizer cls_token已经注册为：obj*’[CLS]’*，XLM 的一个也已经注册为''）。

示例：

# Let's see how to add a new classification token to GPT-2
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2Model.from_pretrained("gpt2")
special_tokens_dict = {"cls_token": "<CLS>"}
num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))
assert tokenizer.cls_token == "<CLS>"

add_tokens

<来源>

( new_tokens: Union special_tokens: bool = False ) → export const metadata = 'undefined';int

参数

• new_tokens（str，tokenizers.AddedToken或str或tokenizers.AddedToken的列表） - 仅当这些标记尚未在词汇表中时才会添加。tokenizers.AddedToken包装了一个字符串标记，让您可以个性化其行为：这个标记是否只匹配一个单词，这个标记是否应该去除左侧的所有潜在空格，这个标记是否应该去除右侧的所有潜在空格等。
  
• special_tokens（bool，可选，默认为False） - 可用于指定标记是否为特殊标记。这主要会改变标准化行为（例如，特殊标记如 CLS 或[MASK]通常不会被小写）。
  请参阅 HuggingFace tokenizers 库中的tokenizers.AddedToken的详细信息。
  

返回

int

将特殊标记添加到词汇表中的数量。

向标记器类添加一组新标记。如果新标记不在词汇表中，则将它们添加到词汇表中，索引从当前词汇表的长度开始，并且在应用标记化算法之前将被隔离。因此，标记化算法的添加标记和词汇表中的标记不会以相同的方式处理。

注意，向词汇表中添加新标记时，您应确保还调整模型的标记嵌入矩阵，以使其嵌入矩阵与标记器匹配。

为了实现这一点，请使用 resize_token_embeddings()方法。

示例：

# Let's see how to increase the vocabulary of Bert model and tokenizer
tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased")
model = BertModel.from_pretrained("bert-base-uncased")
num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"])
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

sanitize_special_tokens

<来源>

( )

sanitize_special_tokens 现在已弃用，仅用于向后兼容，并将在 transformers v5 中移除。

枚举和命名元组

class transformers.tokenization_utils_base.TruncationStrategy

< source >

( value names = None module = None qualname = None type = None start = 1 )

在 PreTrainedTokenizerBase.call() 中 truncation 参数的可能取值。在 IDE 中用于制表完成。

class transformers.CharSpan

< source >

( start: int end: int )

参数

• start (int) — 原始字符串中第一个字符的索引。
  
• end (int) — 原始字符串中最后一个字符后面的字符的索引。
  

原始字符串中的字符范围。

class transformers.TokenSpan

< source >

( start: int end: int )

参数

• start (int) — span 中第一个标记的索引。
  
• end (int) — span 中最后一个标记后面的标记的索引。
  

编码字符串中的标记范围（标记列表）。

Trainer 的实用程序

原始文本：huggingface.co/docs/transformers/v4.37.2/en/internal/trainer_utils

此页面列出了由 Trainer 使用的所有实用函数。

这些大多数只有在研究库中 Trainer 的代码时才有用。

实用程序

class transformers.EvalPrediction

<来源>

( predictions: Union label_ids: Union inputs: Union = None )

参数

• predictions (np.ndarray) — 模型的预测。
  
• label_ids (np.ndarray) — 要匹配的目标。
  
• inputs (np.ndarray, 可选) —
  

评估输出（始终包含标签），用于计算指标。

class transformers.IntervalStrategy

<来源>

( value names = None module = None qualname = None type = None start = 1 )

一个枚举。

transformers.enable_full_determinism

<来源>

( seed: int warn_only: bool = False )

用于在分布式训练期间获得可重复行为的辅助函数。参见

• pytorch.org/docs/stable/notes/randomness.html 适用于 pytorch
  
• www.tensorflow.org/api_docs/python/tf/config/experimental/enable_op_determinism 适用于 tensorflow
  

transformers.set_seed

<来源>

( seed: int )

参数

• seed (int) — 要设置的种子。

用于在random、numpy、torch和/或tf（如果已安装）中设置种子以获得可重复的行为的辅助函数。

transformers.torch_distributed_zero_first

<来源>

( local_rank: int )

参数

• local_rank (int) — 本地进程的等级。

装饰器，使分布式训练中的所有进程等待每个本地主机执行某些操作。

回调内部

class transformers.trainer_callback.CallbackHandler

<来源>

( callbacks model tokenizer optimizer lr_scheduler )

内部类，按顺序调用回调列表。

分布式评估

class transformers.trainer_pt_utils.DistributedTensorGatherer

<来源>

( world_size num_samples make_multiple_of = None padding_index = -100 

参数

• world_size (int) — 分布式训练中使用的进程数。
  
• num_samples (int) — 数据集中的样本数量。
  
• make_multiple_of (int, 可选) — 如果传递，类会假定传递给每个进程的数据集是该参数的倍数（通过添加样本）。
  
• padding_index (int, 可选, 默认为-100) — 如果数组的序列长度不相同时要使用的填充索引。
  

一个负责通过块在 CPU 上正确聚合张量（或嵌套的列表/元组张量）的类。

如果我们的数据集有 16 个样本，每个进程上有 3 个进程的批量大小为 2，并且我们在每一步都进行聚合然后传输到 CPU，我们的采样器将生成以下索引：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1]

为了获得大小为 3 的倍数的数据（以便每个进程获得相同的数据集长度）。然后进程 0、1 和 2 将负责为以下样本进行预测：

• P0: [0, 1, 2, 3, 4, 5]
  
• P1: [6, 7, 8, 9, 10, 11]
  
• P2: [12, 13, 14, 15, 0, 1]
  

每个进程上处理的第一批将是

• P0: [0, 1]
  
• P1: [6, 7]
  
• P2: [12, 13]
  

因此，如果我们在第一批结束时进行聚合，我们将获得一个张量（嵌套的列表/元组张量），对应以下索引：

[0, 1, 6, 7, 12, 13]

如果我们直接连接我们的结果而不采取任何预防措施，用户将在预测循环结束时按此顺序获得索引的预测：

[0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1]

由于某种原因，这不会引起他们的兴趣。这个类就是为了解决这个问题。

add_arrays

<来源>

( arrays )

将arrays添加到内部存储，将在第一次传递数组时将存储初始化为完整大小，以便如果我们绑定要发生 OOM，它会在开始时发生。

finalize

<来源>

( )

返回正确收集的数组并截断到样本数量（因为采样器添加了一些额外的内容，以使每个进程的数据集长度相同）。

Trainer 参数解析器

class transformers.HfArgumentParser

<来源>

( dataclass_types: Union **kwargs )

这个argparse.ArgumentParser的子类使用数据类的类型提示生成参数。

该类设计用于与原生 argparse 很好地配合。特别是，在初始化后可以向解析器添加更多（非数据类支持的）参数，解析后将作为额外的命名空间返回。可选：要创建子参数组，请在数据类中使用_argument_group_name属性。

parse_args_into_dataclasses

<来源>

( args = None return_remaining_strings = False look_for_args_file = True args_filename = None args_file_flag = None ) → export const metadata = 'undefined';Tuple consisting of

返回

由以下内容组成的元组

• 以与它们传递给初始化程序时相同的顺序的数据类实例。abspath
  
• 如果适用，用于在初始化后向解析器添加更多（非数据类支持的）参数的额外命名空间。
  
• 剩余参数字符串的潜在列表。（与 argparse.ArgumentParser.parse_known_args 相同）
  

将命令行参数解析为指定数据类类型的实例。

这依赖于 argparse 的ArgumentParser.parse_known_args。请参阅文档：docs.python.org/3.7/library/argparse.html#argparse.ArgumentParser.parse_args

parse_dict

<来源>

( args: Dict allow_extra_keys: bool = False ) → export const metadata = 'undefined';Tuple consisting of

参数

• args（dict）—包含配置值的字典
  
• allow_extra_keys（bool，可选，默认为False）—默认为 False。如果为 False，则如果字典包含未解析的键，则会引发异常。
  

返回

由以下内容组成的元组

• 以与它们传递给初始化程序时相同的顺序的数据类实例。

另一个不使用argparse的辅助方法，而是使用字典并填充数据类类型。

parse_json_file

<来源>

( json_file: str allow_extra_keys: bool = False ) → export const metadata = 'undefined';Tuple consisting of

参数

• json_file（str或os.PathLike）—要解析的 json 文件的文件名
  
• allow_extra_keys（bool，可选，默认为False）—默认为 False。如果为 False，则如果 json 文件包含未解析的键，则会引发异常。
  

返回

由以下内容组成的元组

• 以与它们传递给初始化程序时相同的顺序的数据类实例。

另一个不使用argparse的辅助方法，而是加载一个 json 文件并填充数据类类型。

parse_yaml_file

<来源>

( yaml_file: str allow_extra_keys: bool = False ) → export const metadata = 'undefined';Tuple consisting of

参数

• yaml_file（str或os.PathLike）—要解析的 yaml 文件的文件名
  
• allow_extra_keys（bool，可选，默认为False）—默认为 False。如果为 False，则如果 json 文件包含未解析的键，则会引发异常。
  

返回

由以下内容组成的元组

• 以与它们传递给初始化程序时相同的顺序的数据类实例。

另一种不使用argparse的辅助方法，而是加载一个 yaml 文件并填充数据类类型。

调试工具

class transformers.debug_utils.DebugUnderflowOverflow

<来源>

( model max_frames_to_save = 21 trace_batch_nums = [] abort_after_batch_num = None )

参数

• model (nn.Module) — 要调试的模型。
  
• max_frames_to_save (int，可选，默认为 21) — 记录多少帧以前
  
• trace_batch_nums(List[int], 可选，默认为[]) — 要跟踪的批次号（关闭检测）
  
• abort_after_batch_num (int，可选) — 是否在某个批次号完成后中止
  

此调试类有助于检测和理解模型何时开始变得非常大或非常小，更重要的是nan或inf权重和激活元素。

有 2 种工作模式：

1. 下溢/溢出检测（默认）
   
2. 没有检测的特定批次绝对最小/最大跟踪
   

模式 1：下溢/溢出检测

激活下溢/溢出检测，使用以下模型初始化对象：

debug_overflow = DebugUnderflowOverflow(model)

然后像平常一样运行训练，如果在权重、输入或输出元素中至少有一个检测到nan或inf，此模块将抛出异常，并打印导致此事件的max_frames_to_save帧，每帧报告

1. 完全限定的模块名称加上运行其forward的类名
   
2. 每个模块权重的所有元素的绝对最小值和最大值，以及输入和输出
   

例如，这是在 fp16 中运行的google/mt5-small的检测报告中的标题和最后几帧

混合精度：

Detected inf/nan during batch_number=0
Last 21 forward frames:
abs min  abs max  metadata [...]
                  encoder.block.2.layer.1.DenseReluDense.wi_0 Linear
2.17e-07 4.50e+00 weight
1.79e-06 4.65e+00 input[0]
2.68e-06 3.70e+01 output
                  encoder.block.2.layer.1.DenseReluDense.wi_1 Linear
8.08e-07 2.66e+01 weight
1.79e-06 4.65e+00 input[0]
1.27e-04 2.37e+02 output
                  encoder.block.2.layer.1.DenseReluDense.wo Linear
1.01e-06 6.44e+00 weight
0.00e+00 9.74e+03 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense
1.79e-06 4.65e+00 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.dropout Dropout
3.18e-04 6.27e+04 input[0]
0.00e+00      inf output

您可以在这里看到，T5DenseGatedGeluDense.forward 的输出激活结果，其绝对最大值约为 62.7K，非常接近 fp16 的 64K 上限。在下一帧中，我们有Dropout，它重新规范化权重，在将一些元素归零后，将绝对最大值推到超过 64K，导致溢出。

正如您所看到的，当数字开始变得非常大时，我们需要查看之前的帧以了解 fp16 数字。

跟踪是在前向挂钩中完成的，该挂钩在forward完成后立即调用。

默认情况下，将打印最后 21 帧。您可以更改默认值以适应您的需求。例如：

debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100)

为了验证您已正确设置此调试功能，并且您打算在可能需要几个小时才能完成的训练中使用它，首先使用正常跟踪启用运行一些批次，如下一节所述。

模式 2. 没有检测的特定批次绝对最小/最大跟踪

第二种工作模式是批次跟踪，关闭下溢/溢出检测功能。

假设您想观察每个forward调用的所有成分的绝对最小值和最大值

给定批次，并且仅对第 1 和第 3 批次执行此操作。然后，实例化此类：

debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3])

现在完整的第 1 和第 3 批次将使用与上述相同的格式进行跟踪。批次从 0 开始索引。

如果您知道程序在某个批次号之后开始表现不佳，那么您可以直接快进到该区域。

提前停止：

您还可以指定在哪个批次号之后停止训练，使用：

debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3], abort_after_batch_num=3)

此功能主要在跟踪模式下有用，但您可以在任何模式下使用它。

性能：

由于此模块在每次前向传播时测量模型的每个权重的绝对min/max，因此会减慢训练速度。因此，请记住在满足调试需求后将其关闭。

生成工具

原始文本：huggingface.co/docs/transformers/v4.37.2/en/internal/generation_utils

此页面列出了  generate()、greedy_search()、contrastive_search()、sample()、beam_search()、beam_sample()、group_beam_search()  和 constrained_beam_search() 使用的所有实用函数。

大多数情况下，这些只有在研究库中生成方法的代码时才有用。

生成输出

generate() 的输出是 ModelOutput 的子类实例。这个输出是一个数据结构，包含了 generate() 返回的所有信息，但也可以用作元组或字典。

这里有一个例子：

from transformers import GPT2Tokenizer, GPT2LMHeadModel
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")
inputs = tokenizer("Hello, my dog is cute and ", return_tensors="pt")
generation_output = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)

generation_output 对象是一个 GenerateDecoderOnlyOutput，正如我们在下面该类的文档中所看到的，它具有以下属性：

• sequences：生成的 token 序列
  
• scores（可选）：语言建模头的预测分数，每个生成步骤
  
• hidden_states（可选）：模型的隐藏状态，每个生成步骤
  
• attentions（可选）：模型的注意力权重，每个生成步骤
  

这里我们有 scores，因为我们传递了 output_scores=True，但我们没有 hidden_states 和 attentions，因为我们没有传递 output_hidden_states=True 或 output_attentions=True。

您可以像通常那样访问每个属性，如果该属性未被模型返回，您将得到 None。在这里，例如 generation_output.scores 是语言建模头生成的所有预测分数，而 generation_output.attentions 是 None。

当将我们的 generation_output 对象用作元组时，它只保留那些没有 None 值的属性。在这里，例如，它有两个元素，loss 然后 logits，所以

generation_output[:2]

例如，将返回元组 (generation_output.sequences, generation_output.scores)。

当将我们的 generation_output 对象用作字典时，它只保留那些没有 None 值的属性。在这里，例如，它有两个键，分别是 sequences 和 scores。

我们在这里记录所有输出类型。

PyTorch

class transformers.generation.GenerateDecoderOnlyOutput

< source >

( sequences: LongTensor = None scores: Optional = None attentions: Optional = None hidden_states: Optional = None past_key_values: Optional = None )

参数

• sequences（形状为 (batch_size, sequence_length) 的 torch.LongTensor） — 生成的序列。第二维（sequence_length）要么等于 max_length，要么如果所有批次由于 eos_token_id 提前结束，则要短一些。
  
• scores（tuple(torch.FloatTensor) 可选，当传递output_scores=True或config.output_scores=True时返回）— 在每个生成步骤中语言建模头的处理预测分数（SoftMax 之前每个词汇标记的分数）。元组torch.FloatTensor，最多包含max_new_tokens个元素（每个生成的标记一个元素），每个张量的形状为(batch_size, config.vocab_size)。
  
• attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的标记一个元素）的元组（解码器的每一层一个元素）的torch.FloatTensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• hidden_states（tuple(tuple(torch.FloatTensor))，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 元组（每个生成的标记一个元素）的元组（解码器的每一层一个元素）的torch.FloatTensor，形状为(batch_size, generated_length, hidden_size)。
  
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 注意：一些模型具有不同的past_key_values格式，请查阅模型的文档进行确认。通常是一个元组（解码器的每一层一个元素）的元组（两个元素，键张量和值张量）。第一个元组的长度为config.n_layers，每个元组有 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)的张量。
  

解码器生成模型的输出，在使用非 beam 方法时。

class transformers.generation.GenerateEncoderDecoderOutput

<来源>

( sequences: LongTensor = None scores: Optional = None encoder_attentions: Optional = None encoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None decoder_hidden_states: Optional = None past_key_values: Optional = None )

参数

• sequences（形状为(batch_size, sequence_length)的torch.LongTensor）— 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则要短。
  
• scores（tuple(torch.FloatTensor) 可选，当传递output_scores=True或config.output_scores=True时返回）— 在每个生成步骤中语言建模头的处理预测分数（SoftMax 之前每个词汇标记的分数）。元组torch.FloatTensor，最多包含max_new_tokens个元素（每个生成的标记一个元素），每个张量的形状为(batch_size, config.vocab_size)。
  
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组的torch.FloatTensor（解码器的每一层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。
  
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 元组的torch.FloatTensor（嵌入的输出一个加上每一层的输出一个）的形状为(batch_size, sequence_length, hidden_size)。
  
• decoder_attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的标记一个元素）的元组（解码器的每一层一个元素）的torch.FloatTensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• cross_attentions (tuple(tuple(torch.FloatTensor)))，可选，当传递output_attentions=True或config.output_attentions=True时返回 — 每个生成的令牌的元组（每个解码器层一个元素）的torch.FloatTensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• decoder_hidden_states (tuple(tuple(torch.FloatTensor)))，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 每个生成的令牌的元组（每个解码器层一个元素）的torch.FloatTensor的元组，形状为(batch_size, generated_length, hidden_size)。
  
• past_key_values (tuple(tuple(torch.FloatTensor)))，可选，当传递use_cache=True或config.use_cache=True时返回 — 注意：一些模型具有不同的past_key_values格式，请查阅模型文档确认。通常是一个元组（解码器每一层一个元素）的元组（两个元素，键张量和值张量）。第一个元组的长度为config.n_layers，每个元组有 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)的张量。
  

在使用非 beam 方法时的编码器-解码器生成模型的输出。

class transformers.generation.GenerateBeamDecoderOnlyOutput

< source >

( sequences: LongTensor = None sequences_scores: Optional = None scores: Optional = None beam_indices: Optional = None attentions: Optional = None hidden_states: Optional = None past_key_values: Optional = None )

参数

• sequences (torch.LongTensor，形状为(batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前结束，则较短。
  
• sequences_scores (torch.FloatTensor，形状为(batch_size*num_return_sequences))，可选，当传递output_scores=True或config.output_scores=True时返回 — 生成sequences的最终 beam 分数。
  
• scores (tuple(torch.FloatTensor)，可选，当传递output_scores=True或config.output_scores=True时返回 — 每一代步每个词汇令牌的 beam 转移分数。beam 转移分数由 tokens 的对数概率条件于该 beam 中先前生成的 tokens 的对数 softmax 组成。具有最多max_new_tokens元素的torch.FloatTensor元组（每个生成的令牌一个元素），每个张量的形状为(batch_size*num_beams*num_return_sequences, config.vocab_size)。
  
• beam_indices (torch.LongTensor)，可选，当传递output_scores=True或config.output_scores=True时返回 — 每一代步生成的令牌 id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的torch.LongTensor。
  
• attentions (tuple(tuple(torch.FloatTensor)))，可选，当传递output_attentions=True或config.output_attentions=True时返回 — 每个生成的令牌的元组（每个解码器层一个元素）的torch.FloatTensor的元组，形状为(batch_size*num_beams, num_heads, generated_length, sequence_length)。
  
• hidden_states (tuple(tuple(torch.FloatTensor)))，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 每个生成的令牌的元组（每个解码器层一个元素）的torch.FloatTensor，形状为(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)。
  
• past_key_values（tuple(tuple(torch.FloatTensor)))，可选，当传递use_cache=True或config.use_cache=True时返回）— 注意：一些模型具有不同的past_key_values格式，请查阅模型的文档。通常是一个元组（解码器每一层一个）的元组（两个元素，键张量和值张量）。第一个元组的长度为config.n_layers，每个元组有 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)的张量。
  

在使用 beam 方法时，仅解码器生成模型的输出。

class transformers.generation.GenerateBeamEncoderDecoderOutput

<来源>

( sequences: LongTensor = None sequences_scores: Optional = None scores: Optional = None beam_indices: Optional = None encoder_attentions: Optional = None encoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None decoder_hidden_states: Optional = None past_key_values: Optional = None )

参数

• sequences（torch.LongTensor，形状为(batch_size*num_return_sequences, sequence_length)）— 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前结束，则较短。
  
• sequences_scores（torch.FloatTensor，形状为(batch_size*num_return_sequences)，可选，当传递output_scores=True或config.output_scores=True时返回）— 生成的sequences的最终 beam 分数。
  
• scores（tuple(torch.FloatTensor)，可选，当传递output_scores=True或config.output_scores=True时返回）— 每一代步骤中每个词汇标记的 beam 转移分数。Beam 转移分数由 tokens 的 log 概率组成，条件是该 beam 中先前生成的 tokens 的 log softmax。torch.FloatTensor的元组，最多有max_new_tokens个元素（每个生成的 token 一个元素），每个张量的形状为(batch_size*num_beams, config.vocab_size)。
  
• beam_indices（torch.LongTensor，可选，当传递output_scores=True或config.output_scores=True时返回）— 每一代步骤中生成的 token id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的torch.LongTensor。
  
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（解码器每一层一个）。
  
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。
  
• decoder_attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每一层一个）的torch.FloatTensor，形状为(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)。
  
• cross_attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每一层一个）的torch.FloatTensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• decoder_hidden_states（tuple(tuple(torch.FloatTensor))，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每一层一个）的torch.FloatTensor，形状为(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)。
  
• past_key_values (tuple(tuple(torch.FloatTensor))), optional, 当传递use_cache=True或config.use_cache=True时返回) — 注意：一些模型具有不同的past_key_values格式，请查阅模型文档。通常是一个元组（解码器每层一个元素）的元组（两个元素，键张量和值张量）。第一个元组的长度为config.n_layers，每个元组有 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)的张量。
  

在使用 beam 方法时，编码器-解码器生成模型的输出。

Transformers 4.37 中文文档（九十九）（4）https://developer.aliyun.com/article/1564044