Transformers 文档

生成实用工具

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始

生成实用工具

此页面列出了 generate() 使用的所有实用工具函数。

生成输出

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

这是一个例子

from transformers import GPT2Tokenizer, GPT2LMHeadModel

tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2LMHeadModel.from_pretrained("openai-community/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: 生成的 tokens 序列
  • scores (可选): 语言建模头的预测分数,用于每个生成步骤
  • hidden_states (可选): 模型的隐藏状态,用于每个生成步骤
  • attentions (可选): 模型的注意力权重,用于每个生成步骤

这里我们有 scores,因为我们传递了 output_scores=True,但我们没有 hidden_statesattentions,因为我们没有传递 output_hidden_states=Trueoutput_attentions=True

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

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

generation_output[:2]

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

当将我们的 generation_output 对象用作字典时,它只保留没有 None 值的属性。例如,这里它有两个键,分别是 sequencesscores

我们在此处记录所有输出类型。

PyTorch

class transformers.generation.GenerateDecoderOnlyOutput

< >

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

参数

  • sequences (torch.LongTensor,形状为 (batch_size, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • scores (tuple(torch.FloatTensor)可选,当 output_scores=True 时返回) — 语言建模头的处理后的预测分数(每个词汇表 token 在 SoftMax 之前的分数),在每个生成步骤中。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • logits (tuple(torch.FloatTensor)可选,当 output_logits=True 时返回) — 语言建模头的未处理的预测分数(每个词汇表 token 在 SoftMax 之前的分数),在每个生成步骤中。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • attentions (tuple(tuple(torch.FloatTensor)), 可选的,当 output_attentions=True 时返回 ) — 元组 (每个生成的 token 一个元素),包含元组 (解码器每一层一个元素),元素为 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • hidden_states (tuple(tuple(torch.FloatTensor)), 可选的,当 output_hidden_states=True 时返回 ) — 元组 (每个生成的 token 一个元素),包含元组 (解码器每一层一个元素),元素为 torch.FloatTensor,形状为 (batch_size, generated_length, hidden_size)
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选的,当 use_cache=True 时返回 ) — 返回模型缓存,用于加速解码。不同模型的缓存格式不同,请查看模型文档。通常是一个 Cache 实例。

仅解码器生成模型的输出,当使用非束搜索方法时。

transformers.generation.GenerateEncoderDecoderOutput

< >

( sequences: LongTensor = None scores: Optional = None logits: 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 提前结束。
  • scores (tuple(torch.FloatTensor) 可选的, returned when output_scores=True) — 语言模型头的处理后预测分数 (每个词汇表 token 在 SoftMax 之前的分数),在每个生成步骤。`torch.FloatTensor` 的元组,最多包含 `max_new_tokens` 个元素 (每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • logits (tuple(torch.FloatTensor) 可选的, returned when output_logits=True) — 语言模型头的未处理预测分数 (每个词汇表 token 在 SoftMax 之前的分数),在每个生成步骤。`torch.FloatTensor` 的元组,最多包含 `max_new_tokens` 个元素 (每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • encoder_attentions (tuple(torch.FloatTensor), 可选的,当 output_attentions=True 时返回 ) — torch.FloatTensor 的元组 (解码器每一层一个元素),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选的,当 output_hidden_states=True 时返回 ) — torch.FloatTensor 的元组 (embedding 输出 + 每一层的输出),形状为 (batch_size, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(torch.FloatTensor)), 可选的,当 output_attentions=True 时返回 ) — 元组 (每个生成的 token 一个元素),包含元组 (解码器每一层一个元素),元素为 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • cross_attentions (tuple(tuple(torch.FloatTensor)), 可选的,当 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 时返回 ) — 元组 (每个生成的 token 一个元素),包含元组 (解码器每一层一个元素),元素为 torch.FloatTensor,形状为 (batch_size, generated_length, hidden_size)
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选的,当传递 use_cache=Trueconfig.use_cache=True 时返回 ) — 返回模型缓存,用于加速解码。不同模型的缓存格式不同,请查看模型文档。通常是一个 Cache 实例。

编码器-解码器生成模型的输出,当使用非束搜索方法时。

transformers.generation.GenerateBeamDecoderOnlyOutput

< >

( sequences: LongTensor = None sequences_scores: Optional = None scores: Optional = None logits: 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), 可选的, returned when output_scores=True) — 生成的 sequences 的最终束分数。
  • scores (tuple(torch.FloatTensor) 可选的, returned when output_scores=True) — 每个词汇表 token 在每个生成步骤的束搜索转移分数。束搜索转移分数由 token 的对数概率组成,该概率以该束中先前生成的 token 的对数 softmax 为条件。`torch.FloatTensor` 的元组,最多包含 max_new_tokens 个元素 (每个生成的 token 一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • logits (tuple(torch.FloatTensor) 可选的, returned when output_logits=True) — 语言模型头的未处理预测分数 (每个词汇表 token 在 SoftMax 之前的分数),在每个生成步骤。`torch.FloatTensor` 的元组,最多包含 max_new_tokens 个元素 (每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • beam_indices (torch.LongTensor , 可选的, returned when output_scores=True) — 每个生成步骤中生成的 token id 的束索引。torch.LongTensor,形状为 (batch_size*num_return_sequences, sequence_length)
  • attentions (tuple(tuple(torch.FloatTensor)), 可选的,当 output_attentions=True 时返回 ) — 元组 (每个生成的 token 一个元素),包含元组 (解码器每一层一个元素),元素为 torch.FloatTensor,形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)
  • hidden_states (tuple(tuple(torch.FloatTensor)), 可选的,当 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))), 可选的,当 use_cache=True 时返回 ) — 返回模型缓存,用于加速解码。不同模型的缓存格式不同,请查看模型文档。通常是一个 Cache 实例。

仅解码器生成模型的输出,当使用束搜索方法时。

transformers.generation.GenerateBeamEncoderDecoderOutput

< >

( sequences: LongTensor = None sequences_scores: Optional = None scores: Optional = None logits: 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 (形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • sequences_scores (形状为 (batch_size*num_return_sequences)torch.FloatTensor, 可选,当 output_scores=True 时返回) — 生成的 sequences 的最终束搜索分数。
  • scores (tuple(torch.FloatTensor) 可选, 当 output_scores=True 时返回) — 每个生成步骤中每个词汇标记的束搜索转移分数。束搜索转移分数由标记的对数概率组成,条件是此束中先前生成的标记的对数 softmax。 torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • logits (tuple(torch.FloatTensor) 可选, 当 output_logits=True 时返回) — 语言建模头的未处理预测分数(SoftMax 之前每个词汇标记的分数),在每个生成步骤中返回。 torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • beam_indices (torch.LongTensor, 可选, 当 output_scores=True 时返回) — 每个生成步骤中生成的标记 id 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor
  • encoder_attentions (tuple(torch.FloatTensor), 可选, 当 output_attentions=True 时返回) — torch.FloatTensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当 output_hidden_states=True 时返回) — torch.FloatTensor 的元组(嵌入输出一个,每层输出一个),形状为 (batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 torch.FloatTensor,形状为 (batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)
  • cross_attentions (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • decoder_hidden_states (tuple(tuple(torch.FloatTensor)), 可选, 当 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 时返回) — 返回模型缓存,用于加速解码。不同模型具有不同的缓存格式,请查看模型文档。通常是 Cache 实例。

编码器-解码器生成模型的输出,当使用束搜索方法时。

TensorFlow

class transformers.generation.TFGreedySearchEncoderDecoderOutput

< >

( sequences: Tensor = 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 )

参数

  • sequences (形状为 (batch_size, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言建模头的已处理预测分数(SoftMax 之前每个词汇标记的分数),在每个生成步骤中返回。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的元组(嵌入输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 tf.Tensor,形状为 (batch_size, generated_length, hidden_size)

使用贪婪搜索的编码器-解码器生成模型输出的基类。解码器(分别是编码器)的隐藏状态和注意力权重可以通过 encoder_attentions 和 encoder_hidden_states 属性(分别是 decoder_attentions 和 decoder_hidden_states 属性)访问。

class transformers.generation.TFGreedySearchDecoderOnlyOutput

< >

( sequences: Tensor = None scores: Optional = None attentions: Optional = None hidden_states: Optional = None )

参数

  • sequences (形状为 (batch_size, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=True 或当 config.output_scores=True 时返回) — 语言建模头的已处理预测分数(SoftMax 之前每个词汇标记的分数),在每个生成步骤中返回。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • hidden_states (tuple(tuple(tf.Tensor)), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size, generated_length, hidden_size)tf.Tensor。(可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回)

使用贪婪搜索的仅解码器生成模型输出的基类。

class transformers.generation.TFSampleEncoderDecoderOutput

< >

( sequences: Tensor = 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 )

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 等于 max_length,或者如果所有批次由于 eos_token_id 提前完成,则更短。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言模型头的已处理预测分数(每个生成步骤中每个词汇表 token 的 SoftMax 之前的分数)。tf.Tensor 元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个 tensor 的形状为 (batch_size*num_return_sequences, config.vocab_size)
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size*num_return_sequences, num_heads, sequence_length, sequence_length)tf.Tensor 元组(解码器的每一层一个)。
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size*num_return_sequences, sequence_length, hidden_size)tf.Tensor 元组(embeddings 的输出 + 每一层的输出各一个)。
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size*num_return_sequences, num_heads, generated_length, sequence_length)tf.Tensor
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size*num_return_sequences, generated_length, hidden_size)tf.Tensor

使用采样的编码器-解码器生成模型输出的基类。解码器(分别是编码器)的隐藏状态和注意力权重可以通过 encoder_attentions 和 encoder_hidden_states 属性(分别是 decoder_attentions 和 decoder_hidden_states 属性)访问。

class transformers.generation.TFSampleDecoderOnlyOutput

< >

( sequences: Tensor = None scores: Optional = None attentions: Optional = None hidden_states: Optional = None )

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 等于 max_length,或者如果所有批次由于 eos_token_id 提前完成,则更短。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言模型头的已处理预测分数(每个生成步骤中每个词汇表 token 的 SoftMax 之前的分数)。tf.Tensor 元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个 tensor 的形状为 (batch_size*num_return_sequences, config.vocab_size)
  • attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (num_return_sequences*batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (num_return_sequences*batch_size, generated_length, hidden_size)tf.Tensor

使用采样的仅解码器生成模型输出的基类。

class transformers.generation.TFBeamSearchEncoderDecoderOutput

< >

( sequences: Tensor = 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 )

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 等于 max_length,或者如果所有批次由于 eos_token_id 提前完成,则更短。
  • sequences_scores (形状为 (batch_size*num_return_sequences)tf.Tensor, 可选, 当传递 output_scores=True 或当 config.output_scores=True 时返回) — 生成的 sequences 的最终 beam 分数。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中每个词汇表 token 的已处理 beam 分数。Beam 分数包含每个词汇表 token 的 log softmax 分数,以及此 beam 中先前生成的 token 的 log softmax 的总和。tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个 tensor 的形状为 (batch_size*num_beams, config.vocab_size)
  • beam_indices (tf.Tensor, 可选, 当传递 output_scores=True 或当 config.output_scores=True 时返回) — 每个生成步骤中生成的 token id 的 Beam 索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)tf.Tensor 元组(解码器的每一层一个)。
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)tf.Tensor 元组(embeddings 的输出 + 每一层的输出各一个)。
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)tf.Tensor
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的 token 一个元素),元素为元组(解码器的每一层一个元素),包含形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size)tf.Tensor

使用 beam search 的编码器-解码器生成模型输出的基类。解码器(分别是编码器)的隐藏状态和注意力权重可以通过 encoder_attentions 和 encoder_hidden_states 属性(分别是 decoder_attentions 和 decoder_hidden_states 属性)访问。

class transformers.generation.TFBeamSearchDecoderOnlyOutput

< >

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

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前完成)。
  • sequences_scores (形状为 (batch_size*num_return_sequences)tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 生成的 sequences 的最终束搜索分数。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中每个词汇表标记的处理后的束搜索分数。束搜索分数由每个词汇表标记的 log softmax 分数以及此束中先前生成的标记的 log softmax 总和组成。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams*num_return_sequences, config.vocab_size)
  • beam_indices (tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中生成的标记 ID 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)tf.Tensor
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size)tf.Tensor

使用束搜索的仅解码器生成模型输出的基类。

class transformers.generation.TFBeamSampleEncoderDecoderOutput

< >

( sequences: Tensor = 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 )

参数

  • sequences (形状为 (batch_size*num_beams, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前完成)。
  • sequences_scores (形状为 (batch_size * num_return_sequence)tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 生成的 sequences 的最终束搜索分数。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中每个词汇表标记的处理后的束搜索分数。束搜索分数由每个词汇表标记的 log softmax 分数以及此束中先前生成的标记的 log softmax 总和组成。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • beam_indices (tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中生成的标记 ID 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 的元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size*num_beams, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)tf.Tensor
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams, generated_length, hidden_size)tf.Tensor

使用束采样的编码器-解码器生成模型输出的基类。解码器(分别是编码器)的隐藏状态和注意力权重可以通过 encoder_attentionsencoder_hidden_states 属性(分别是 decoder_attentionsdecoder_hidden_states 属性)访问。

class transformers.generation.TFBeamSampleDecoderOnlyOutput

< >

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

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前完成)。
  • sequences_scores (形状为 (batch_size * num_return_sequence)tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 生成的 sequences 的最终束搜索分数。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中每个词汇表标记的处理后的束搜索分数。束搜索分数由每个词汇表标记的 log softmax 分数以及此束中先前生成的标记的 log softmax 总和组成。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams*num_return_sequences, config.vocab_size)
  • beam_indices (tf.Tensor, 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 每个生成步骤中生成的标记 ID 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)tf.Tensor
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),其中包含元组(解码器的每一层一个元素),这些元组是形状为 (batch_size*num_beams, generated_length, hidden_size)tf.Tensor

使用束采样的仅解码器生成模型输出的基类。

class transformers.generation.TFContrastiveSearchEncoderDecoderOutput

< >

( sequences: Tensor = 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 )

参数

  • sequences (形状为 (batch_size, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言模型头的已处理预测得分(每个生成步骤中每个词汇表标记在 SoftMax 之前的得分)。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 的元组(嵌入输出 + 解码器每一层的输出各一个),形状为 (batch_size, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的 tf.Tensor 的形状为 (batch_size, num_heads, generated_length, sequence_length)
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的 tf.Tensor 的形状为 (batch_size, num_heads, generated_length, sequence_length)
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的 tf.Tensor 的形状为 (batch_size, generated_length, hidden_size)

使用对比搜索的编码器-解码器生成模型的输出基类。解码器(分别是编码器)的隐藏状态和注意力权重可以通过 encoder_attentions 和 encoder_hidden_states 属性(分别是 decoder_attentions 和 decoder_hidden_states 属性)访问

class transformers.generation.TFContrastiveSearchDecoderOnlyOutput

< >

( sequences: Tensor = None scores: Optional = None attentions: Optional = None hidden_states: Optional = None )

参数

  • sequences (形状为 (batch_size, sequence_length)tf.Tensor) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前完成。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言模型头的已处理预测得分(每个生成步骤中每个词汇表标记在 SoftMax 之前的得分)。 tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的 tf.Tensor 的形状为 (batch_size, num_heads, generated_length, sequence_length)
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的 tf.Tensor 的形状为 (batch_size, generated_length, hidden_size)

仅解码器生成模型的输出基类,使用对比搜索。

FLAX

class transformers.generation.FlaxSampleOutput

< >

( sequences: Array = None )

参数

  • sequences (形状为 (batch_size, max_length)jnp.ndarray) — 生成的序列。

Flax 仅解码器生成模型的输出基类,使用采样。

replace

< >

( **updates )

“返回一个新对象,将指定的字段替换为新值。

class transformers.generation.FlaxGreedySearchOutput

< >

( sequences: Array = None )

参数

  • sequences (形状为 (batch_size, max_length)jnp.ndarray) — 生成的序列。

Flax 仅解码器生成模型的输出基类,使用贪婪搜索。

replace

< >

( **updates )

“返回一个新对象,将指定的字段替换为新值。

class transformers.generation.FlaxBeamSearchOutput

< >

( sequences: Array = None scores: Array = None )

参数

  • sequences (形状为 (batch_size, max_length)jnp.ndarray) — 生成的序列。
  • scores (形状为 (batch_size,)jnp.ndarray) — 生成序列的得分(对数概率)。

Flax 仅解码器生成模型的输出基类,使用贪婪搜索。

replace

< >

( **updates )

“返回一个新对象,将指定的字段替换为新值。

LogitsProcessor

LogitsProcessor 可以用于修改语言模型头的预测得分,以进行生成。

PyTorch

class transformers.AlternatingCodebooksLogitsProcessor

< >

( input_start_len: int semantic_vocab_size: int codebook_size: int )

参数

  • input_start_len (int) — 初始输入序列的长度。
  • semantic_vocab_size (int) — 语义部分的词汇表大小,即与语义词汇表关联的 token 数量。
  • codebook_size (int) — 与码本关联的 token 数量。

LogitsProcessor 强制执行 Bark 的两个码本之间的交替生成。

此 logits 处理器专门与 Bark 的精细子模型兼容。 有关示例,请参阅模型文档。

__call__

< >

( input_ids: LongTensor scores: FloatTensor )

class transformers.ClassifierFreeGuidanceLogitsProcessor

< >

( guidance_scale )

参数

  • guidance_scale (float) — 分类器自由引导(CFG)的引导比例。通过设置 guidance_scale > 1 启用 CFG。较高的引导比例鼓励模型生成与输入提示更紧密相关的样本,但通常以较差的质量为代价。

LogitsProcessor 用于分类器自由引导(CFG)。分数在批次维度上拆分,其中前半部分对应于条件 logits(从输入提示预测),后半部分对应于无条件 logits(从空提示或“null”提示预测)。处理器计算条件 logits 和无条件 logits 的加权平均值,由 guidance_scale 参数化。

有关更多信息,请参阅论文

此 logits 处理器专门与 MusicGen 兼容

示例

>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")

>>> inputs = processor(
...     text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
...     padding=True,
...     return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 什么是输入 ID?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EncoderNoRepeatNGramLogitsProcessor

< >

( encoder_ngram_size: int encoder_input_ids: LongTensor )

参数

  • encoder_ngram_size (int) — 大小为 ngram_size 的所有 n-gram 只能在编码器输入 ID 中出现。
  • encoder_input_ids (int) — 不应在解码器 ID 中重复的 encoder_input_ids。

LogitsProcessor,其工作方式类似于 NoRepeatNGramLogitsProcessor,但专门用于防止重复提示中存在的 n-gram。

它旨在通过防止生成先前对话轮次中存在的 n-gram 来促进语言模型的健谈性。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt")

>>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one.
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: I love cats. What do you

>>> # With this logits processor, we can prevent Bob from repeating Alice's opinion.
>>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: My cats are very cute.

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 什么是输入 ID?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EncoderRepetitionPenaltyLogitsProcessor

< >

( penalty: float encoder_input_ids: LongTensor )

参数

  • penalty (float) — 重复惩罚的参数。1.0 表示没有惩罚。高于 1.0 会奖励提示 token。介于 0.0 和 1.0 之间会惩罚提示 token。
  • encoder_input_ids (torch.LongTensor) — 应在解码器 ID 中重复的 encoder_input_ids。

LogitsProcessor,其工作方式类似于 RepetitionPenaltyLogitsProcessor,但对提示中存在的 token 应用反向惩罚。换句话说,高于 1.0 的惩罚会增加选择提示中存在的 token 的几率。

它旨在避免输入接地的任务(如摘要)中的幻觉。虽然最初用于编码器-解码器模型,但它也可以与仅解码器模型(如 LLM)一起使用。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["Alice and Bob. The third member's name was"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was not mentioned.

>>> # With the `encoder_repetition_penalty` argument we can trigger this logits processor in `generate`, which can
>>> # promote the use of prompt tokens ("Bob" in this example)
>>> gen_out = model.generate(**inputs, encoder_repetition_penalty=1.2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was Bob. The third member's name was Bob.

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 什么是输入 ID?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EpsilonLogitsWarper

< >

( epsilon: float filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • epsilon (float) — 如果设置为 > 0,则仅保留概率 epsilon 或更高的 token 用于生成。
  • filter_value (float, optional, defaults to -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能过滤的最小 token 数。

LogitsProcessor,它执行 epsilon 采样,即限制为 prob >= epsilon 的 token。如果没有 token 满足此约束,则采用最大的 min_tokens_to_keep 个 token。 有关更多信息,请参阅 Truncation Sampling as Language Model Desmoothing

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With epsilon sampling, the output gets restricted to high-probability tokens. Note that this is similar to
>>> # Top P sampling, which restricts tokens based on their cumulative probability.
>>> # Pro tip: The paper recomends using `epsilon_cutoff` values between 3e-4 and 9e-4
>>> outputs = model.generate(**inputs, do_sample=True, epsilon_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EtaLogitsWarper

< >

( epsilon: float filter_value: float = -inf min_tokens_to_keep: int = 1 device: str = 'cpu' )

参数

  • epsilon (float) — 范围在 (0, 1) 之间的浮点值。用于计算动态截止值 eta 的超参数。论文中建议的值范围为 3e-4 到 4e-3,具体取决于模型的大小。
  • filter_value (float, 可选,默认为 -inf) — 所有低于动态截止值 eta 的值都将设置为此浮点值。当需要修改 logits 以排除完全从生成中排除的极低概率 tokens 时,此参数非常有用。
  • min_tokens_to_keep (int, 可选,默认为 1) — 指定必须保留用于生成的 tokens 的最小数量,无论其概率如何。例如,如果将 min_tokens_to_keep 设置为 1,则始终至少保留一个 token 用于生成,即使所有 tokens 的概率都低于截止值 eta
  • device (str, 可选,默认为 "cpu") — 分配 tensors 的设备。

LogitsProcessor,执行 eta 采样,这是一种过滤掉概率低于动态截止值 eta 的 tokens 的技术,其中 eta 基于超参数 epsilon 和 token 概率的熵的组合计算得出,即 eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))。如果没有 tokens 满足此约束,则取最大的 min_tokens_to_keep 个 tokens。它解决了神经语言模型生成的长文本样本中质量较差的问题,从而产生更连贯和流畅的文本。有关更多信息,请参阅 Truncation Sampling as Language Model Desmoothing。注意:必须将 do_sample 设置为 True,此 LogitsProcessor 才能工作。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With eta sampling, the output gets restricted to high-probability tokens. You can see it as a dynamic form of
>>> # epsilon sampling that adapts its cutoff probability based on the entropy (high entropy = lower cutoff).
>>> # Pro tip: The paper recomends using `eta_cutoff` values between 3e-4 to 4e-3
>>> outputs = model.generate(**inputs, do_sample=True, eta_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ExponentialDecayLengthPenalty

< >

( exponential_decay_length_penalty: Tuple eos_token_id: Union input_ids_seq_length: int )

参数

  • exponential_decay_length_penalty (tuple(int, float)) — 此元组应包含:(start_index, decay_factor),其中 start_index 指示惩罚开始的位置,decay_factor 表示指数衰减的因子
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 id。
  • input_ids_seq_length (int) — 输入序列的长度。

LogitsProcessor,在达到 start_index 后,指数级增加 eos_token_id 的得分。这允许生成更短的序列,而无需硬性截止,从而允许在有意义的位置预测 eos_token

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> text = "Just wanted to let you know, I"
>>> inputs = tokenizer(text, return_tensors="pt")

>>> # Let's consider that we want short sentences, so we limit `max_length=30`. However, we observe that the answer
>>> # tends to end abruptly.
>>> set_seed(1)
>>> outputs = model.generate(**inputs, do_sample=True, temperature=0.9, max_length=30, pad_token_id=50256)
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010. Although

>>> # To promote the appearance of the EOS token at the right time, we add the `exponential_decay_length_penalty =
>>> # (start_index, decay_factor)`. Instead of cutting at max_tokens, the output comes to an end before and usually
>>> # with more meaning. What happens is that starting from `start_index` the EOS token score will be increased
>>> # by `decay_factor` exponentially. However, if you set a high decay factor, you may also end up with abruptly
>>> # ending sequences.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.6),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network
which<|endoftext|>

>>> # With a small decay factor, you will have a higher chance of getting a meaningful sequence.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.01),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010.<|endoftext|>

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

  • bos_token_id (int) — 强制作为第一个生成的 token 的 id。

LogitsProcessor,强制指定的 token 作为第一个生成的 token。用于 encoder-decoder 模型。

示例

>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")

>>> inputs = tokenizer("Translate from English to German: I love cats.", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad> Ich liebe Kitty.</s>

>>> # We can use `forced_bos_token_id` to force the start of generation with an encoder-decoder model
>>> # (including forcing it to end straight away with an EOS token)
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_bos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad></s>

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ForcedEOSTokenLogitsProcessor

< >

( max_length: int eos_token_id: Union device: str = 'cpu' )

参数

  • max_length (int) — 要生成的序列的最大长度。
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 id。
  • device (str, 可选, 默认为 "cpu") — 用于分配张量的设备。

LogitsProcessor,当达到 max_length 时,强制将指定的 token 作为最后一个生成的 token。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8

>>> # `forced_eos_token_id` ensures the generation ends with a EOS token
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_eos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7,<|endoftext|>

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.HammingDiversityLogitsProcessor

< >

( diversity_penalty: float num_beams: int num_beam_groups: int )

参数

  • diversity_penalty (float) — 如果一个 beam 生成的 token 与特定时间步中来自其他组的任何 beam 相同,则从该 beam 的分数中减去此值。较高的 diversity_penalty 将强制 beam 之间具有更大的多样性。调整此值有助于在多样性和自然可能性之间取得平衡。
  • num_beams (int) — beam search 的 beam 数量。1 表示不使用 beam search。
  • num_beam_groups (int) — 为了确保不同 beam 组之间的多样性,将 num_beams 分成的组数。有关更多详细信息,请参阅 本文

LogitsProcessor,用于强制执行多样化的 beam search。

请注意,此 logits processor 仅对 PreTrainedModel.group_beam_search 有效。有关更多详细信息,请参阅 Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence Models

传统的 beam search 通常会在不同的 beam 之间生成非常相似的序列。HammingDiversityLogitsProcessor 通过惩罚在同一时间步生成其他 beam 已选择的 token 的 beam 来解决这个问题。

示例

>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
>>> import torch

>>> # Initialize the model and tokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-base")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("google-t5/t5-base")

>>> # A long text about the solar system
>>> text = (
...     "The Solar System is a gravitationally bound system comprising the Sun and the objects that orbit it, "
...     "either directly or indirectly. Of the objects that orbit the Sun directly, the largest are the eight "
...     "planets, with the remainder being smaller objects, such as the five dwarf planets and small Solar System "
...     "bodies. The Solar System formed 4.6 billion years ago from the gravitational collapse of a giant "
...     "interstellar molecular cloud."
... )
>>> inputs = tokenizer("summarize: " + text, return_tensors="pt")

>>> # Generate diverse summary
>>> outputs_diverse = model.generate(
...     **inputs,
...     num_beam_groups=2,
...     diversity_penalty=10.0,
...     max_length=100,
...     num_beams=4,
...     num_return_sequences=2,
... )
>>> summaries_diverse = tokenizer.batch_decode(outputs_diverse, skip_special_tokens=True)

>>> # Generate non-diverse summary
>>> outputs_non_diverse = model.generate(
...     **inputs,
...     max_length=100,
...     num_beams=4,
...     num_return_sequences=2,
... )
>>> summary_non_diverse = tokenizer.batch_decode(outputs_non_diverse, skip_special_tokens=True)

>>> # With `diversity_penalty`, the resulting beams are much more diverse
>>> print(summary_non_diverse)
['the solar system formed 4.6 billion years ago from the collapse of a giant interstellar molecular cloud. of the objects that orbit the Sun directly, the largest are the eight planets.',
'the Solar System formed 4.6 billion years ago from the collapse of a giant interstellar molecular cloud. of the objects that orbit the Sun directly, the largest are the eight planets.']

>>> print(summaries_diverse)
['the solar system formed 4.6 billion years ago from the collapse of a giant interstellar molecular cloud. of the objects that orbit the Sun directly, the largest are the eight planets.',
'the solar system formed 4.6 billion years ago from the collapse of a giant interstellar molecular cloud. of the objects that orbit the Sun directly, the largest are the eight planets. the rest of the objects are smaller objects, such as the five dwarf planets and small solar system bodies.']

__call__

< >

( input_ids: LongTensor scores: FloatTensor current_tokens: LongTensor beam_group_idx: int ) torch.FloatTensor,形状为 (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。
  • current_tokens (torch.LongTensor,形状为 (batch_size)) — 词汇表中输入序列 token 的索引,对应于当前生成步骤中其他 beam 组选择的 token。
  • beam_group_idx (int) — 当前正在处理的 beam 组的索引。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.InfNanRemoveLogitsProcessor

< >

( )

LogitsProcessor,用于删除所有 naninf 值,以避免生成方法失败。请注意,logits processor 仅应在必要时使用,因为它会减慢生成方法的速度。

此 logits processor 没有 generate 示例,因为不应存在保证其使用的正确 flag 组合。

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.LogitNormalization

< >

( )

LogitsProcessor,用于使用 log-softmax 归一化分数。在应用 logits processor 或 warper 之后,在 beam search 期间归一化分数非常重要,因为此库中使用的搜索算法不执行此操作(仅在之前执行,但它们可能需要重新归一化),但在比较假设时,它仍然假设分数已归一化。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> import torch

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, the scores are not normalized -- the sum of their exponentials is NOT a normalized probability
>>> # distribution, summing to 1
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
False

>>> # Normalizing them may have a positive impact on beam methods, or when using the scores on your application
>>> outputs = model.generate(**inputs, renormalize_logits=True, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
True

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.LogitsProcessor

< >

( )

可应用于生成过程的所有 logit processor 的抽象基类。

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.LogitsProcessorList

< >

( iterable = () )

此类可用于创建 LogitsProcessor 的列表,以便随后处理 scores 输入张量。此类继承自 list 并添加了一个特定的 call 方法,以将每个 LogitsProcessor 应用于输入。

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 tokens 的 log softmax。
  • kwargs (Dict[str, Any], 可选) — 附加的 kwargs,特定于 logits 处理器。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.MinLengthLogitsProcessor

< >

( min_length: int eos_token_id: Union device: str = 'cpu' )

参数

  • min_length (int) — 低于此最小长度时,eos_token_id 的得分将被设置为 -float("Inf")
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 ID。
  • device (str, 可选, 默认为 "cpu") — 分配 tensors 的设备。

LogitsProcessor 通过将 EOS 概率设置为 0 来强制执行最小长度。请注意,对于像大多数 LLM 这样的仅解码器模型,长度包括提示。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("A number:", return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_length` to a value smaller than the uncontrolled output length has no impact
>>> gen_out = model.generate(**inputs, min_length=3)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting a larger `min_length` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_length=10)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand, nine hundred and ninety-four

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 tokens 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.MinNewTokensLengthLogitsProcessor

< >

( prompt_length_to_skip: int min_new_tokens: int eos_token_id: Union device: str = 'cpu' )

参数

  • prompt_length_to_skip (int) — 输入 tokens 长度。当与 generate 一起使用时,不是有效的参数,因为它将自动分配输入长度。
  • min_new_tokens (int) — 低于此最小 tokens 长度时,eos_token_id 的得分将被设置为 -float("Inf")
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 ID。
  • device (str, 可选, 默认为 "cpu") — 分配 tensors 的设备。

LogitsProcessor 通过将 EOS(序列结束)token 概率设置为 0 来强制执行最小新 tokens 长度。与 MinLengthLogitsProcessor 相反,此处理器忽略提示。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["A number:"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_new_tokens` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_new_tokens=2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇 tokens 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.MinPLogitsWarper

< >

( min_p: float filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • min_p (float) — 最小 token 概率,它将按最有可能的 token 的概率进行缩放。它必须是介于 0 和 1 之间的值。典型值在 0.01-0.2 范围内,与在 0.99-0.8 范围内设置 top_p 具有相当的选择性(使用普通 top_p 值的相反值)。
  • filter_value (float, 可选, 默认为 -inf) — 所有被过滤的值都将设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的最小 token 数。

LogitsProcessor 执行 min-p,即保留所有高于最小概率的 tokens,并按最有可能的 token 的概率进行缩放。因此,在存在高概率 tokens 的情况下,过滤器变得更具侵略性,这表明输出是可信的,我们不应该偏离它。

通常与 TemperatureLogitsWarper 一起使用。用作 TopPLogitsWarperTopKLogitsWarper 的替代方案。

由 @menhguin 和 @kalomaze(github handles)创建。代码改编自此外部 PR

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `min_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `min_p` in the 0.01-0.2 range.
>>> outputs = model.generate(**inputs, do_sample=True, min_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9

__call__

< >

( input_ids: LongTensor scores: FloatTensor )

class transformers.NoBadWordsLogitsProcessor

< >

( bad_words_ids: List eos_token_id: Union = None )

参数

  • bad_words_ids (List[List[int]]) — 不允许生成的 token id 列表。
  • eos_token_id (Union[int, List[int], torch.Tensor], 可选) — 序列结束 token 的 id。

LogitsProcessor,它强制指定的序列永远不会被选中。

为了获得不应出现在生成文本中的单词的 token id,请确保在初始化 tokenizer 时设置 add_prefix_space=True,并使用 tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space 参数仅适用于某些慢速 tokenizer,因为快速 tokenizer 的前缀行为来自 pre tokenizers。 阅读此处了解更多信息。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["In a word, the cake is a"], return_tensors="pt")

>>> output_ids = model.generate(inputs["input_ids"], max_new_tokens=5, pad_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a mess.

>>> # Now let's take the bad words out. Please note that the tokenizer is initialized differently
>>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True)


>>> def get_tokens_as_list(word_list):
...     "Converts a sequence of words into a list of tokens"
...     tokens_list = []
...     for word in word_list:
...         tokenized_word = tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0]
...         tokens_list.append(tokenized_word)
...     return tokens_list


>>> bad_words_ids = get_tokens_as_list(word_list=["mess"])
>>> output_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=5, bad_words_ids=bad_words_ids, pad_token_id=tokenizer.eos_token_id
... )
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a surprise.

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 ID?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.NoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

  • ngram_size (int) — 大小为 ngram_size 的所有 n-gram 只能出现一次。

N-gram 是从文本序列中提取的“n”个连续单词、字符或 token 的组。 给定句子:“She runs fast”,二元语法 (n=2) 将是 (“she”, “runs”) 和 (“runs”, “fast”)。 在文本生成中,避免重复单词序列可以提供更多样化的输出。 此LogitsProcessor 通过将禁止 token 的分数设置为负无穷大来强制不重复 n-gram,从而在进一步处理分数时消除这些 token 的考虑。 请注意,对于像大多数 LLM 这样的仅解码器模型,提示也被考虑在内以获得 n-gram。Fairseq

谨慎使用 n-gram 惩罚。 例如,在关于纽约市的文章中惩罚 2-gram(二元语法)可能会导致不良结果,即城市名称在整篇文章中仅出现一次。参考

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["Today I"], return_tensors="pt")

>>> output = model.generate(**inputs)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I’m not sure if I’m going to be able to do it.

>>> # Now let's add ngram size using `no_repeat_ngram_size`. This stops the repetitions ("I’m") in the output.
>>> output = model.generate(**inputs, no_repeat_ngram_size=2)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I’m not sure if I can get a better understanding of the nature of this issue

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 ID?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.PrefixConstrainedLogitsProcessor

< >

( prefix_allowed_tokens_fn: Callable num_beams: int )

参数

  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]) — 此函数约束集束搜索在每个步骤仅使用允许的 token。此函数接受 2 个参数 inputs_ids 和批次 ID batch_id。它必须返回一个列表,其中包含允许的 token,用于基于先前生成的 token inputs_ids 和批次 ID batch_id 的下一步生成。

LogitsProcessor,它强制执行约束生成,并且对于前缀条件约束生成非常有用。 有关更多信息,请参见自回归实体检索

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice and Bob", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=5)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob are friends

>>> # We can contrain it with `prefix_allowed_tokens_fn` to force a certain behavior based on a prefix.
>>> # For instance, we can force an entire entity to be generated when its beginning is detected.
>>> entity = tokenizer(" Bob Marley", return_tensors="pt").input_ids[0]  # 3 tokens
>>> def prefix_allowed_tokens_fn(batch_id, input_ids):
...     '''
...     Attempts to generate 'Bob Marley' when 'Bob' is detected.
...     In this case, `batch_id` is not used, but you can set rules for each batch member.
...     '''
...     if input_ids[-1] == entity[0]:
...         return [entity[1].item()]
...     elif input_ids[-2] == entity[0] and input_ids[-1] == entity[1]:
...         return [entity[2].item()]
...     return list(range(tokenizer.vocab_size))  # If no match, allow all tokens

>>> outputs = model.generate(**inputs, max_new_tokens=5, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob Marley

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 ID?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.RepetitionPenaltyLogitsProcessor

< >

( penalty: float )

参数

  • penalty (float) — 重复惩罚的参数。 1.0 表示没有惩罚。 高于 1.0 会惩罚先前生成的 token。 介于 0.0 和 1.0 之间会奖励先前生成的 token。

LogitsProcessor,它通过惩罚来防止先前 token 的重复。 此惩罚最多对每个 token 应用一次。 请注意,对于像大多数 LLM 这样的仅解码器模型,考虑的 token 包括提示。

在最初的论文中,作者建议使用大约 1.2 的惩罚值,以在真实生成和缺乏重复之间取得良好的平衡。 要惩罚和减少重复,请使用高于 1.0 的 penalty 值,其中值越高惩罚越强。 要奖励和鼓励重复,请使用介于 0.0 和 1.0 之间的 penalty 值,其中值越低奖励越强。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> # Initializing the model and tokenizer for it
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["I'm not going to"], return_tensors="pt")

>>> # This shows a normal generate without any specific parameters
>>> summary_ids = model.generate(**inputs)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'm going to be able to do that

>>> # This generates a penalty for repeated tokens
>>> penalized_ids = model.generate(**inputs, repetition_penalty=1.1)
>>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'll just have to go out and play

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 ID?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.SequenceBiasLogitsProcessor

< >

( sequence_bias: List )

参数

  • sequence_bias (List[List[Union[List[int], float]]]) — 列表的列表,将 token 序列映射到其偏差项(例如 [[[10, 45], -2.0], [[64], -7.5]])。 正偏差会增加选择序列的几率,而负偏差则相反。 如果序列的长度为 1,则始终应用其偏差。 否则,仅当即将完成所讨论的序列时(在此处理器应用之后的 token 选择步骤中),才应用偏差。

LogitsProcessor,它对序列应用加性偏差。 当下一个生成的 token 可以完成序列时,偏差将应用于序列的最后一个 token。 因此,为了充分利用具有多个 token 的偏差序列,请考虑使用集束方法(以优雅地解决具有负偏差的部分完成序列)并将偏差应用于其前缀(以确保较早应用偏差)。

为了获得您想要偏差的序列的 token id,请确保在初始化 tokenizer 时设置 add_prefix_space=True,并使用 tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space 参数仅适用于某些慢速 tokenizer,因为快速 tokenizer 的前缀行为来自 pre tokenizers。 阅读此处了解更多信息。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt")

>>> summary_ids = model.generate(inputs["input_ids"], max_new_tokens=4)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald J. Trump Jr

>>> # Now let's control generation through a bias. Please note that the tokenizer is initialized differently!
>>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True)


>>> def get_tokens(word):
...     return tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0]


>>> # If we add a negative bias without beam search, it may become "stuck" in a prefix without good continuations
>>> sequence_bias = [get_tokens("Trump"), -10.0]
>>> biased_ids = model.generate(inputs["input_ids"], max_new_tokens=4, sequence_bias=sequence_bias)
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald J. Donald,

>>> biased_ids = model.generate(inputs["input_ids"], max_new_tokens=4, num_beams=4, sequence_bias=sequence_bias)
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald Rumsfeld,

>>> # We can also add a positive bias to nudge the model towards specific tokens or continuations
>>> sequence_bias = [get_tokens("Donald Duck"), 10.0]
>>> biased_ids = model.generate(inputs["input_ids"], max_new_tokens=4, num_beams=4, sequence_bias=sequence_bias)
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald Duck.

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。什么是输入 ID?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.SuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index device: str = 'cpu' )

SuppressTokensAtBeginLogitsProcessor 处理器会在 generate 函数开始生成时,使用 begin_index 个 tokens 立即抑制 token 列表。这应确保 begin_suppress_tokens 定义的 tokens 不会在开头生成。最初为 Whisper 创建。

示例

>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has `begin_suppress_tokens` set by default (= `[220, 50256]`). 50256 is the EOS token, so this means
>>> # it can't generate and EOS token in the first iteration, but it can in the others.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[0][0, 50256])
tensor(-inf)
>>> print(outputs.scores[-1][0, 50256])  # in other places we can see some probability mass for EOS
tensor(29.9010)

>>> # If we disable `begin_suppress_tokens`, we can generate EOS in the first iteration.
>>> outputs = model.generate(
...     **inputs, return_dict_in_generate=True, output_scores=True, begin_suppress_tokens=None
... )
>>> print(outputs.scores[0][0, 50256])
tensor(11.2027)

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.SuppressTokensLogitsProcessor

< >

( suppress_tokens device: str = 'cpu' )

此处理器可用于抑制 token 列表。处理器会将其 log probs 设置为 -inf,以便它们不会被生成。最初为 Whisper 创建。

示例

>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has a long list of suppressed tokens. For instance, in this case, the token 1 is suppressed by default.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[1][0, 1])  # 1 (and not 0) is the first freely generated token
tensor(-inf)

>>> # If we disable `suppress_tokens`, we can generate it.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, suppress_tokens=None)
>>> print(outputs.scores[1][0, 1])
tensor(6.0678)

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.TemperatureLogitsWarper

< >

( temperature: float )

参数

  • temperature (float) — 严格正浮点值,用于调节 logits 分布。小于 1 的值会降低随机性(反之亦然),其中 0 相当于将所有概率质量转移到最可能的 token。

LogitsProcessor 用于 temperature(指数缩放输出概率分布),这实际上意味着它可以控制预测 tokens 的随机性。通常与 TopPLogitsWarperTopKLogitsWarper 一起使用。

确保 generate 参数中包含 do_sample=True,否则 temperature 值将不起作用。

示例

>>> import torch
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(0)  # for reproducibility

>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> model.config.pad_token_id = model.config.eos_token_id
>>> inputs = tokenizer(["Hugging Face Company is"], return_tensors="pt")

>>> # With temperature=1.0, the default, we consistently get random outputs due to random sampling.
>>> generate_kwargs = {"max_new_tokens": 10, "do_sample": True, "temperature": 1.0, "num_return_sequences": 2}
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is one of these companies that is going to take a',
"Hugging Face Company is a brand created by Brian A. O'Neil"]

>>> # However, with temperature close to 0, it approximates greedy decoding strategies (invariant)
>>> generate_kwargs["temperature"] = 0.0001
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is a company that has been around for over 20 years',
'Hugging Face Company is a company that has been around for over 20 years']

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.TopKLogitsWarper

< >

( top_k: int filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_k (int) — 保留用于 top-k 过滤的最高概率词汇 tokens 的数量。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 无法过滤的 tokens 的最小数量。

LogitsProcessor,执行 top-k,即限制为 k 个最高概率元素。通常与 TemperatureLogitsWarperTopPLogitsWarper 一起使用。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: A, B, C, D", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E — S — O, P — R

>>> # With `top_k` sampling, the output gets restricted the k most likely tokens.
>>> # Pro tip: In practice, LLMs use `top_k` in the 5-50 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_k=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E, F, G, H, I

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.TopPLogitsWarper

< >

( top_p: float filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_p (float) — 如果设置为 < 1,则仅保留概率总和达到 top_p 或更高的最小概率 tokens 集合,用于生成。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 无法过滤的 tokens 的最小数量。

LogitsProcessor,执行 top-p,即限制为概率总和 prob_cut_off <= prob_cut_off 的 top tokens。通常与 TemperatureLogitsWarperTopKLogitsWarper 一起使用。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `top_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.TypicalLogitsWarper

< >

( mass: float = 0.9 filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • mass (float, 可选, 默认为 0.9) — typical_p 的值,介于 0 和 1 之间(包含 0 和 1),默认为 0.9。
  • filter_value (float, 可选, 默认为 -inf) — 所有被过滤的值都将被设置为这个浮点数值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤掉的最小 token 数量。

LogitsProcessor,执行典型解码。灵感来源于人类如何使用语言,它优先考虑对数概率接近 token 概率分布熵的 token。这意味着在这个过程中,最有可能的 token 可能会被丢弃。

有关更多信息,请参阅 自然语言生成的典型解码

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("1, 2, 3", return_tensors="pt")

>>> # We can see that greedy decoding produces a sequence of numbers
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

>>> # For this particular seed, we can see that sampling produces nearly the same low-information (= low entropy)
>>> # sequence
>>> set_seed(18)
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9 and 10

>>> # With `typical_p` set, the most obvious sequence is no longer produced, which may be good for your problem
>>> set_seed(18)
>>> outputs = model.generate(
...     **inputs, do_sample=True, typical_p=0.1, return_dict_in_generate=True, output_scores=True
... )
>>> print(tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0])
1, 2, 3 and 5

>>> # We can see that the token corresponding to "4" (token 934) in the second position, the most likely token
>>> # as seen with greedy decoding, was entirely blocked out
>>> print(outputs.scores[1][0, 934])
tensor(-inf)

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (形状为 (batch_size, config.vocab_size)torch.FloatTensor) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇表的 logits,或者当使用束搜索时,可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor

< >

( guidance_scale: float model unconditional_ids: Optional = None unconditional_attention_mask: Optional = None use_cache: Optional = True )

参数

  • guidance_scale (float) — 用于无分类器引导(CFG)的引导缩放比例。通过设置 guidance_scale != 1 启用 CFG。较高的引导缩放比例鼓励模型生成与输入提示更紧密相关的样本,但通常以质量较差为代价。小于 1 的值具有相反的效果,同时使与 negative_prompt_ids(如果有)一起提供的负面提示充当正面提示。
  • model (PreTrainedModel) — 计算无条件分数的模型。据推测与计算条件分数的模型相同。两个模型必须使用相同的 tokenizer。
  • unconditional_ids (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 用于无条件分支的词汇表中输入序列 token 的索引。如果未设置,则默认为提示的最后一个 token。
  • unconditional_attention_mask (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — unconditional_ids 的注意力掩码。
  • use_cache (bool, 可选, 默认为 True) — 是否在负面提示前向传递期间缓存键/值。

用于无分类器引导(CFG)的 Logits 处理器。处理器计算来自提示条件和提示无条件(或负面)logits 的分数的加权平均值,由 guidance_scale 参数化。无条件分数通过使用 unconditional_ids 分支提示 model 在内部计算。

有关更多信息,请参阅 论文

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Today, a dragon flew over Paris, France,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=1.5)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 50 people and injuring more than 100'

>>> # with a negative prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=2, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 130 people. French media reported that'

>>> # with a positive prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=0, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
"Today, a dragon flew over Paris, France, and I'm very happy to be here. I"

__call__

< >

( input_ids scores )

class transformers.WhisperTimeStampLogitsProcessor

< >

( generate_config begin_index: Optional = None _detect_timestamp_from_logprob: Optional = None )

参数

  • generate_config (GenerateConfig) — 用于生成输出的生成配置。以下参数是必需的:eos_token_id (int, 可选, 默认为 50257):序列结束 token 的 ID。no_timestamps_token_id (int, 可选, 默认为 50363):"<|notimestamps|>" token 的 ID。max_initial_timestamp_index (int, 可选, 默认为 1):用于设置初始时间戳的最大值。这用于防止模型预测的时间戳过于遥远。
  • begin_index (Optional, 可选) — 模型生成的第一个 token 的 token 索引。
  • _detect_timestamp_from_logprob (bool, 可选) — 是否可以从所有时间戳的 logprob 中预测时间戳。

LogitsProcessor,它修改 logits 以生成转录中的时间戳。当输入 token 达到特定阈值时,处理器将分数设置为负无穷大。处理器确保时间戳 token 成对出现,方法是屏蔽掉会破坏此配对模式的 logits。这样做是为了保持生成的时间戳的一致性和结构。它还确保,当采样任何时间戳 token 的预测概率大于任何单个非时间戳 token 时,这些非时间戳 logits 将被设置为负无穷大。这样做是为了确保生成时间戳而不是其他可能的 token。

有关更多信息,请参阅 论文

示例

>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration, GenerationConfig
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[3]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> #Displaying timestamps
>>> generated_ids = model.generate(inputs=input_features, return_timestamps=True)
>>> transcription = processor.batch_decode(generated_ids, decode_with_timestamps=True)[0]
>>> print("Transcription:", transcription)
Transcription: <|startoftranscript|><|0.00|> He has grave doubts whether Sir Frederick Layton's work is really Greek after all, and can<|6.44|><|6.44|> discover in it but little of rocky Ithaca.<|9.44|><|endoftext|>


>>> #No timestamps & change EOS:
>>> #This allows the user to select a specific token to terminate the sequence on, in this case it's the word "can"(460)
>>> model.generation_config.eos_token_id = 460
>>> generated_ids = model.generate(inputs=input_features,return_timestamps=False)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print("Transcription:", transcription)
Transcription:  He has grave doubts whether Sir Frederick Layton's work is really Greek after all and can

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

  • input_ids (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列 token 的索引。什么是输入 IDs?
  • scores (形状为 (batch_size, config.vocab_size)torch.FloatTensor) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇表的 logits,或者当使用束搜索时,可以是每个词汇表 token 的 log softmax。

返回值

torch.FloatTensor of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.WatermarkLogitsProcessor

< >

( vocab_size device greenlist_ratio: float = 0.25 bias: float = 2.0 hashing_key: int = 15485863 seeding_scheme: str = 'lefthash' context_width: int = 1 )

参数

  • vocab_size (int) — 模型 tokenizer 的 vocab_size。用于计算“绿色” tokens 比率。
  • device (str) — 模型分配到的设备。
  • greenlist_ratio (float, optional, 可选, 默认为 0.25) — “绿色” tokens 占词汇表大小的比率。默认为 0.25。
  • bias (float, optional, 可选, 默认为 2.0) — 添加到选定的“绿色” tokens 的 logits 的偏差。如果文本生成质量下降,请考虑降低 bias。建议值在 [0.5, 2.0] 范围内。默认为 2.0。
  • hashing_key (int, optional, 可选, 默认为 15485863) — 用于哈希的密钥。如果您部署此水印,我们建议使用另一个私钥。默认为 15485863(第一百万个素数)。
  • seeding_scheme (str, optional, 可选, 默认为 "lefthash") — 用于选择“绿色” tokens 的 seeding 方案。接受以下值:
    • “lefthash”(默认):“绿色” tokens 选择取决于最后一个 token(论文中的算法 2)
    • “selfhash”:“绿色” tokens 选择取决于当前的 token 本身(论文中的算法 3)。此方案的缺点是它考虑了所有可能的下一个 token,可能比“lefthash”慢。要用于 seeding 的先前 tokens 的上下文长度。更高的上下文长度使水印更加健壮。
  • context_width (int, 可选, 默认为 1) — 设置种子时要使用的先前 tokens 的数量。

用于为生成的文本添加水印的 Logits 处理器。该处理器通过在生成下一个 token 之前,向随机选择的“绿色” tokens 集合添加小的偏差来修改模型输出分数。“绿色” tokens 选择过程取决于所使用的 seeding_scheme。此代码基于 原始 repo

由此 LogitsProcessor 生成的文本可以使用 WatermarkDetector 进行检测。有关详细信息,请参阅 call()

有关更多信息,请参阅 论文

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkingConfig

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Alice and Bob are"], return_tensors="pt")

>>> # normal generation
>>> out = model.generate(inputs["input_ids"], max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both in the same room.\n\n"I\'m not sure if you\'re'

>>> # watermarked generation
>>> watermarking_config = WatermarkingConfig(bias=2.5, context_width=2, seeding_scheme="selfhash")
>>> out = model.generate(inputs["input_ids"], watermarking_config=watermarking_config, max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both still alive and well and the story is pretty much a one-hour adventure'

>>> # to detect watermarked text use the WatermarkDetector class
>>> from transformers import WatermarkDetector
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config= watermarking_config)
>>> detection_preds = detector(out)
>>> detection_preds
array([ True])

__call__

< >

( input_ids: LongTensor scores: FloatTensor )

TensorFlow

class transformers.TFForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

  • bos_token_id (int) — 强制作为第一个生成的 token 的 id。

TFLogitsProcessor,它强制将指定的 token 作为第一个生成的 token。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFForcedEOSTokenLogitsProcessor

< >

( max_length: int eos_token_id: int )

参数

  • max_length (int) — 要生成的序列的最大长度。
  • eos_token_id (int) — 当达到 max_length 时,强制作为最后一个生成的 token 的 id。

TFLogitsProcessor,它强制将指定的 token 作为达到 max_length 时的最后一个生成的 token。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFForceTokensLogitsProcessor

< >

( force_token_map: List )

此处理器接受整数对的列表,该列表指示从生成索引到 token 索引的映射,这些 token 将在采样之前被强制执行。处理器将把它们的 log probs 设置为 0,并将所有其他 tokens 设置为 -inf,以便在它们对应的索引处进行采样。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFLogitsProcessor

< >

( )

可应用于生成过程的所有 logit processor 的抽象基类。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int ) tf.Tensor,形状为 (batch_size, config.vocab_size)

参数

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

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

    什么是输入 IDs?

  • scores (形状为 (batch_size, config.vocab_size)tf.Tensor) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇表的 logits;当使用 beam search 时,这些可以是每个词汇表 token 的 log softmax。
  • cur_len (int) — 有效输入序列 tokens 的当前长度。在 TF 实现中,input_ids 的序列长度是可以产生的最大长度,我们需要知道哪些 token 是有效的。
  • kwargs (Dict[str, Any], 可选) — 额外的 logits 处理器特定 kwargs。

返回值

形状为 (batch_size, config.vocab_size)tf.Tensor

处理后的预测分数。

用于处理 logits 的 TF 方法。

class transformers.TFLogitsProcessorList

< >

( iterable = () )

此类可用于创建 TFLogitsProcessor 的列表,以便随后处理 scores 输入张量。此类继承自 list,并添加了一个特定的 call 方法,以将每个 TFLogitsProcessor 应用于输入。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int **kwargs ) tf.Tensor,形状为 (batch_size, config.vocab_size)

参数

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

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

    什么是输入 IDs?

  • scores (tf.Tensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇标记的 log softmax。
  • cur_len (int) — 有效输入序列标记的当前长度。在 TF 实现中,input_ids 的序列长度是生成 (generate) 函数可以产生的最大长度,我们需要知道哪些标记是有效的。
  • kwargs (Dict[str, Any], 可选) — 额外的特定于 logits 处理器的 kwargs。

返回值

形状为 (batch_size, config.vocab_size)tf.Tensor

处理后的预测分数。

class transformers.TFLogitsWarper

< >

( )

所有可以在使用多项式采样的生成过程中应用的 logits 变形器的抽象基类。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int ) tf.Tensor,形状为 (batch_size, config.vocab_size)

参数

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

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

    什么是输入 IDs?

  • scores (tf.Tensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测得分。当不使用束搜索时,这些可以是每个词汇的 logits;当使用束搜索时,这些可以是每个词汇标记的 log softmax。
  • cur_len (int) — 有效输入序列标记的当前长度。在 TF 实现中,input_ids 的序列长度是生成 (generate) 函数可以产生的最大长度,我们需要知道哪些标记是有效的。
  • kwargs (Dict[str, Any], 可选) — 额外的特定于 logits 处理器的 kwargs。

返回值

形状为 (batch_size, config.vocab_size)tf.Tensor

处理后的预测分数。

用于变形 logits 的 TF 方法。

class transformers.TFMinLengthLogitsProcessor

< >

( min_length: int eos_token_id: int )

参数

  • min_length (int) — 低于此最小长度时,eos_token_id 的分数将被设置为 -float("Inf")
  • eos_token_id (int) — 序列结束 (end-of-sequence) 标记的 id。

TFLogitsProcessor,通过将 EOS 概率设置为 0 来强制执行最小长度。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFNoBadWordsLogitsProcessor

< >

( bad_words_ids: List eos_token_id: int )

参数

  • bad_words_ids (List[List[int]]) — 不允许生成的标记 id 列表的列表。为了获得不应出现在生成文本中的词语的标记,请确保在初始化 tokenizer 时设置 add_prefix_space=True,并使用 tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space 参数仅受某些慢速 tokenizer 支持,因为快速 tokenizer 的前缀行为来自 pre tokenizers。在此处阅读更多信息: here
  • eos_token_id (int) — 序列结束 (end-of-sequence) 标记的 id。

TFLogitsProcessor,强制指定序列永远不会被采样。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFNoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

  • ngram_size (int) — 大小为 ngram_size 的所有 n-gram 只能出现一次。

TFLogitsProcessor,强制不重复 n-gram。请参阅 Fairseq

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFRepetitionPenaltyLogitsProcessor

< >

( penalty: float )

参数

  • repetition_penalty (float) — 重复惩罚的参数。1.0 表示没有惩罚。有关更多详细信息,请参阅 本文

TFLogitsProcessor,对重复序列强制执行指数惩罚。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFSuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index )

TFSuppressTokensAtBeginLogitsProcessorgenerate 函数开始使用 begin_index 标记生成时立即禁止标记列表。这应确保由 begin_suppress_tokens 定义的标记在生成开始时不会被采样。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFSuppressTokensLogitsProcessor

< >

( suppress_tokens )

此处理器可用于抑制令牌列表。处理器将把它们的对数概率设置为 -inf,以便它们不会被采样。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFTemperatureLogitsWarper

< >

( temperature: float )

参数

  • temperature (float) — 用于调整 logits 分布的值。

TFLogitsWarper 用于温度 (指数缩放输出概率分布) 。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFTopKLogitsWarper

< >

( top_k: int filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_k (int) — 为 top-k 过滤保留的最高概率词汇令牌的数量。
  • filter_value (float, optional, defaults to -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 无法过滤的最小令牌数。

TFLogitsWarper 执行 top-k,即限制为 k 个最高概率元素。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFTopPLogitsWarper

< >

( top_p: float filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_p (float) — 如果设置为 < 1,则仅保留概率总和达到 `top_p` 或更高的最小的最有可能令牌集用于生成。
  • filter_value (float, optional, defaults to -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 无法过滤的最小令牌数。

TFLogitsWarper 执行 top-p,即限制为总和 <= prob_cut_off 的顶部令牌。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

FLAX

class transformers.FlaxForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

  • bos_token_id (int) — 强制作为第一个生成的令牌的令牌 ID。

FlaxLogitsProcessor,它强制将指定的令牌作为第一个生成的令牌。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxForcedEOSTokenLogitsProcessor

< >

( max_length: int eos_token_id: int )

参数

  • max_length (int) — 要生成的序列的最大长度。
  • eos_token_id (int) — 当达到 max_length 时,强制作为最后一个生成的令牌的令牌 ID。

FlaxLogitsProcessor,当达到 `max_length` 时,它强制将指定的令牌作为最后一个生成的令牌。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxForceTokensLogitsProcessor

< >

( force_token_map )

参数

  • force_token_map (list) — 提供令牌 ID 和索引的映射,在这些索引处它们将被强制采样。

FlaxLogitsProcessor,它接受整数对列表,该列表指示从生成索引到令牌索引的映射,这些令牌索引将在采样之前被强制执行。处理器将把它们的对数概率设置为 0,并将所有其他令牌设置为 `-inf`,以便它们在其对应的索引处被采样。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxLogitsProcessor

< >

( )

可应用于生成过程的所有 logit processor 的抽象基类。

__call__

< >

( input_ids: Array scores: Array ) jnp.ndarray of shape (batch_size, config.vocab_size)

参数

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

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

    什么是 input IDs?

  • scores (jnp.ndarray of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。 当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。
  • kwargs (Dict[str, Any], optional) — 额外的 logits 处理器特定 kwargs。

返回值

jnp.ndarray of shape (batch_size, config.vocab_size)

处理后的预测分数。

用于处理 logits 的 Flax 方法。

class transformers.FlaxLogitsProcessorList

< >

( iterable = () )

此类可用于创建 FlaxLogitsProcessorFlaxLogitsWarper 的列表,以便后续处理 scores 输入张量。 此类继承自 list,并添加了一个特定的 *call* 方法,以将每个 FlaxLogitsProcessorFlaxLogitsWarper 应用于输入。

__call__

< >

( input_ids: Array scores: Array cur_len: int **kwargs ) jnp.ndarray of shape (batch_size, config.vocab_size)

参数

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

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

    什么是 input IDs?

  • scores (jnp.ndarray of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。 当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。
  • kwargs (Dict[str, Any], optional) — 额外的 logits 处理器特定 kwargs。

返回值

jnp.ndarray of shape (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.FlaxLogitsWarper

< >

( )

所有可以在使用多项式采样的生成过程中应用的 logits 变形器的抽象基类。

__call__

< >

( input_ids: Array scores: Array ) jnp.ndarray of shape (batch_size, config.vocab_size)

参数

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

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

    什么是 input IDs?

  • scores (jnp.ndarray of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。 当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。
  • kwargs (Dict[str, Any], optional) — 额外的 logits 处理器特定 kwargs。

返回值

jnp.ndarray of shape (batch_size, config.vocab_size)

处理后的预测分数。

用于 warping logits 的 Flax 方法。

class transformers.FlaxMinLengthLogitsProcessor

< >

( min_length: int eos_token_id: int )

参数

  • min_length (int) — 最小长度,低于此长度,eos_token_id 的分数将设置为 -float("Inf")
  • eos_token_id (int) — end-of-sequence token 的 id。

FlaxLogitsProcessor 通过将 EOS 概率设置为 0 来强制执行最小长度。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxSuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index )

参数

  • begin_suppress_tokens (List[int]) — 不采样的 Tokens 列表。
  • begin_index (int) — Tokens 被抑制的索引。

FlaxLogitsProcessorgenerate 函数开始使用 begin_index tokens 生成时,抑制 token 列表。 这应确保由 begin_suppress_tokens 定义的 tokens 在生成开始时不会被采样。

__call__

< >

( input_ids scores cur_len: int )

class transformers.FlaxSuppressTokensLogitsProcessor

< >

( suppress_tokens: list )

参数

  • suppress_tokens (list) — 不采样的 Tokens 列表。

FlaxLogitsProcessor 在每个解码步骤抑制 token 列表。 处理器将把它们的 log probs 设置为 -inf,以便它们不被采样。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxTemperatureLogitsWarper

< >

( temperature: float )

参数

  • temperature (float) — 用于调整 logits 分布的值。

FlaxLogitsWarper 用于温度(指数缩放输出概率分布)。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxTopKLogitsWarper

< >

( top_k: int filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_k (int) — 用于 top-k 过滤的最高概率词汇 tokens 的数量。
  • filter_value (float, optional, defaults to -inf) — 所有被过滤的值都将被设置为这个浮点数值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能被过滤的 tokens 的最小数量。

FlaxLogitsWarper,执行 top-k 操作,即限制为 k 个最高概率元素。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxTopPLogitsWarper

< >

( top_p: float filter_value: float = -inf min_tokens_to_keep: int = 1 )

参数

  • top_p (float) — 如果设置为 < 1,则仅保留概率总和达到 top_p 或更高的最小概率 tokens 集合,用于生成。
  • filter_value (float, optional, defaults to -inf) — 所有被过滤的值都将被设置为这个浮点数值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能被过滤的 tokens 的最小数量。

FlaxLogitsWarper,执行 top-p 操作,即限制为概率总和 prob_cut_off <= prob_cut_off 的顶部 tokens。

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxWhisperTimeStampLogitsProcessor

< >

( generate_config model_config decoder_input_length )

参数

  • generate_config (GenerateConfig) — 用于生成输出的生成配置。 以下参数是必需的: eos_token_id (int, optional, defaults to 50257): end-of-sequence token 的 id。 no_timestamps_token_id (int, optional, defaults to 50363): "<|notimestamps|>" token 的 id。 max_initial_timestamp_index (int, optional, defaults to 1): 用于设置初始时间戳的最大值。 这用于防止模型预测过远的未来时间戳。

Whisper 特定处理器。 此处理器可用于强制使用 tokens 列表。 处理器将它们的对数概率设置为 inf,以便在它们对应的索引处进行采样。

__call__

< >

( input_ids scores cur_len )

StoppingCriteria

StoppingCriteria 可用于更改何时停止生成(EOS token 除外)。 请注意,这仅适用于我们的 PyTorch 实现。

class transformers.StoppingCriteria

< >

( )

可在生成期间应用的所有停止条件 (stopping criteria) 的抽象基类。

如果您的停止条件取决于 scores 输入,请确保您将 return_dict_in_generate=True, output_scores=True 传递给 generate

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

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

    什么是输入 IDs?

  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。 这些可以是 SoftMax 之前每个词汇表 token 的分数,也可以是 SoftMax 之后每个词汇表 token 的分数。 如果此停止条件取决于 scores 输入,请确保您将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], optional) — 其他停止条件特定的 kwargs。

class transformers.StoppingCriteriaList

< >

( iterable = () )

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

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

    什么是输入 IDs?

  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。 这些可以是 SoftMax 之前每个词汇表 token 的分数,也可以是 SoftMax 之后每个词汇表 token 的分数。 如果此停止条件取决于 scores 输入,请确保您将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], optional) — Additional stopping criteria specific kwargs.

transformers.MaxLengthCriteria

< >

max_length: int max_position_embeddings: Optional = None

参数

  • max_length (int) — 输出序列可以拥有的最大长度,以 token 数量计。
  • max_position_embeddings (int, optional) — 模型最大长度,由模型的 config.max_position_embeddings 属性定义。

此类可用于在生成的 token 总数超过 max_length 时停止生成。请注意,对于仅解码器类型的 transformers,这将包括初始提示 token。

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

    索引可以使用 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 的详细信息。

    什么是输入 IDs?

  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。这些可以是 SoftMax 之前每个词汇表 token 的分数,也可以是 SoftMax 之后每个词汇表 token 的分数。 如果此停止标准依赖于 scores 输入,请确保您将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], optional) — 额外的特定于停止标准的 kwargs。

transformers.MaxTimeCriteria

< >

max_time: float initial_timestamp: Optional = None

参数

  • max_time (float) — 生成允许的最大时间,单位为秒。
  • initial_time (float, optional, defaults to time.time()) — 生成允许时间的开始时间,默认为 time.time()

此类可用于在完整生成时间超过一定量时停止生成。 默认情况下,时间将在您初始化此函数时开始计算。 您可以通过传递 initial_time 来覆盖此设置。

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

    索引可以使用 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 的详细信息。

    什么是输入 IDs?

  • scores (torch.FloatTensor,形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。这些可以是 SoftMax 之前每个词汇表 token 的分数,也可以是 SoftMax 之后每个词汇表 token 的分数。 如果此停止标准依赖于 scores 输入,请确保您将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], optional) — 额外的特定于停止标准的 kwargs。

transformers.StopStringCriteria

< >

tokenizer: PreTrainedTokenizerBase stop_strings: Union

参数

  • tokenizer (PreTrainedTokenizer) — 模型的关联 tokenizer (用于提取词汇表和 token 化终止序列)
  • stop_strings (Union[str, List[str]]) — 应该结束生成的字符串列表。 如果传递字符串,则将其视为包含单个元素的列表。

此类可用于在生成特定的字符串序列时停止生成。 它将字符串与 tokenizer 词汇表一起预处理,以查找 token 可以有效完成停止字符串的位置。

一旦生成完成任何停止字符串的 token,生成就会停止。 我们希望捕获解码输出中存在停止字符串的任何实例,这意味着我们还必须捕获一端或两端都“悬垂”的情况。 为了更具体地说明这一点,对于停止字符串“stop”,以下任何 token 序列都将触发匹配

  • [“st”, “op”]
  • [“stop”]
  • [“st”, “opera”]
  • [“sto”, “pper”]
  • [“las”, “topper”]
  • [“s”, “to”, “pped”]

请注意,只有当停止字符串位于生成序列的末尾时,才会触发匹配。 换句话说,以下序列不会触发匹配

  • [“stop”, “at”]
  • [“st”, “op”, “at”]
  • [“st”, “opera”, “tion”]

这些不是匹配项的原因是停止字符串与最后一个 token 不重叠。 如果您可以从序列末尾删除一个或多个 token 而不破坏停止字符串,则此标准将不会匹配该停止字符串。 这是设计使然; 因为此检查在每次生成 token 后运行,所以如果生成了有效的停止字符串,我们不会错过,但我们不想仅仅因为停止字符串存在于过去的 input_ids 中的某个位置而停止生成。

但是,匹配实际上是如何执行的呢? 我们以一种非常令人困惑的方式进行操作,因为我们希望整个匹配过程都可以使用 Torch 或 XLA 进行编译,这意味着我们不能使用标准的字符串方法。 但是,通过一些工作,可以使用纯 tensor 操作来完成字符串匹配。 我们将首先描述我们使用标准字符串操作使用的算法,然后在最后解释如何将其转换为纯 tensor 操作。

该算法的关键是一个观察结果:由于停止字符串必须与 token 序列的末尾重叠,因此我们可以从序列的末尾开始并向后工作。 具体来说,我们检查最后一个 token 的开头和 stop_string 的结尾之间是否存在重叠,或者换句话说,对于某些 i > 0,stop_string[-i:] == token[:i]。 如果您查看上面的正面示例,您会看到所有示例中的最后一个 token 都满足此属性

  • [“st”, “op”](重叠部分为“op”,重叠长度 == 2)
  • [“stop”](重叠部分为“stop”,重叠长度 == 4)
  • [“st”, “opera”](重叠部分为“op”,重叠长度 == 2)
  • [“sto”, “pper”](重叠部分为“p”,重叠长度 == 1)
  • [“las”, “topper”](重叠部分为“top”,重叠长度 == 3)
  • [“s”, “to”, “pped”](重叠部分为“p”,重叠长度 == 1)

不可能构建一个不具有此属性的匹配序列(您可以随意自行验证)。 但是,尽管最后一个 token 的开头和停止字符串的结尾之间的这种重叠对于匹配是必要的,但它还不够。 我们还需要检查 token 序列的其余部分是否与停止字符串一致。

我们该怎么做呢? 让我们以 [“s”, “to”, “pped”] 为例。 我们知道最后一个 token “pped” 与停止字符串 “stop” 有 1 个字符的重叠。 然后我们回到前一个 token “to”。 由于我们已经匹配了停止字符串中的 1 个字符,因此要检查的剩余部分是 “sto”。 我们检查下一个 token “to” 是否与剩余部分的末尾匹配,结果是匹配的。 我们现在已经匹配了停止字符串中的 3 个字符,要匹配的剩余部分是 “s”。 我们再次回到前一个 token,它也是 “s”。 这是一个匹配项,因此我们已匹配了整个停止字符串。

但是,当 token 从停止字符串的开头开始运行时,它如何工作呢? 让我们考虑 [“las”, “topper”] 的示例。 最后一个 token “topper” 与停止字符串 “stop” 有 3 个字符的重叠。 因此,要匹配的剩余停止字符串是 “s”。 我们回到前一个 token “las”。 因为要匹配的剩余部分只是 “s”,长度为 1,所以我们只考虑 token 中的最后 1 个字符,即 “s”。 这与停止字符串匹配,因此整个字符串都匹配。

但是,我们如何使用 tensor 操作来计算这些匹配项呢? 简单来说:我们有效地预先计算所有 token 的必要信息! 对于每个 token,我们计算

  • 它与停止字符串结尾的重叠部分(如果有)
  • token 匹配的停止字符串内的位置,包括超出开头运行的匹配项。
  • token 的总长度

例如,对于 token “pped”,我们将计算 1 个字符的结尾重叠,没有内部匹配位置,长度为 4。 对于 token “to”,我们将计算没有结尾重叠,1 个内部匹配位置(从结尾开始计数),长度为 2。 对于 token “s”,我们将计算没有结尾重叠,1 个内部匹配位置(同样从结尾开始计数)和长度为 1。

只要我们掌握了这些信息,我们就可以执行上述算法,而无需任何字符串比较操作。 我们只需执行以下步骤

  • 检查最后一个 token 是否与开始字符串有结尾重叠
  • 向后继续,跟踪到目前为止我们匹配了多少停止字符串
  • 在每个点,检查下一个 token 是否将当前位置作为其有效位置之一
  • 继续,直到匹配失败,或者我们完全匹配整个停止字符串

再次考虑 [“s”, “to”, “pped”] 作为示例。“pped” 的结尾重叠为 1,因此我们可以开始匹配。 到目前为止,我们已匹配 1 个字符,因此我们检查下一个 token “to” 是否将 1 作为有效位置(同样,从结尾开始计数)。 它是的,因此我们将 “to” 的长度添加到我们的位置跟踪器。 我们现在已经匹配了 3 个字符,因此我们检查下一个 token “s” 是否将 3 作为有效位置。 它是的,因此我们将其长度添加到位置跟踪器。 位置跟踪器现在为 4,即停止字符串的长度。 我们已匹配了整个停止字符串。

在第二种情况 [“las”, “topper”] 中,“topper” 的结尾重叠为 3,因此我们可以开始匹配。 到目前为止,我们已匹配 3 个字符,因此我们检查下一个 token “las” 是否将 3 作为有效位置。 它是的,因为我们允许 token 匹配超出停止字符串开头的位置。 我们将其长度添加到位置跟踪器。 位置跟踪器现在为 6,大于停止字符串的长度! 不过,不要惊慌失措 - 这也算作停止字符串的匹配项。 我们已匹配了整个停止字符串。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2")
>>> inputs = tokenizer("The biggest states in the USA by land area:", return_tensors="pt")

>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas
- California

>>> # Passing one or more stop strings will halt generation after those strings are emitted
>>> # Note that generating with stop strings requires you to pass the tokenizer too
>>> gen_out = model.generate(**inputs, stop_strings=["Texas"], tokenizer=tokenizer)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

    索引可以使用 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 的详细信息。

    什么是输入 IDs?

  • scores (torch.FloatTensor, 形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。 这些可以是 SoftMax 之前的每个词汇表 token 的分数,也可以是 SoftMax 之后的每个词汇表 token 的分数。 如果此停止条件取决于 scores 输入,请确保将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], 可选) — 附加的特定于停止条件的 kwargs。

class transformers.EosTokenCriteria

< >

( eos_token_id: Union )

参数

  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 id。

此类可用于在生成 “序列结束” token 时停止生成。 默认情况下,它使用 model.generation_config.eos_token_id

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

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

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

    什么是输入 ID?

  • scores (torch.FloatTensor, 形状为 (batch_size, config.vocab_size)) — 语言模型头的预测分数。 这些可以是 SoftMax 之前的每个词汇表 token 的分数,也可以是 SoftMax 之后的每个词汇表 token 的分数。 如果此停止条件取决于 scores 输入,请确保将 return_dict_in_generate=True, output_scores=True 传递给 generate
  • kwargs (Dict[str, Any], 可选) — 附加的特定于停止条件的 kwargs。

约束

可以使用 Constraint 来强制生成在输出中包含特定的 token 或序列。 请注意,这仅适用于我们的 PyTorch 实现。

class transformers.Constraint

< >

( )

可应用于生成期间的所有约束的抽象基类。 它必须定义如何满足约束。

所有继承 Constraint 的类都必须遵循以下要求:

completed = False
while not completed:
    _, completed = constraint.update(constraint.advance())

将始终终止(停止)。

advance

< >

( ) token_ids (Union[int, List[int], None])

返回值

token_ids (Union[int, List[int], None])

  • 一个使约束前进的单个 token ID (int),或
  • 一个可能使约束前进的 token ID 列表
  • 如果约束已完成或无法前进,则为 None

调用时,返回将使此约束更接近满足的 token。

copy

< >

( stateful = False ) constraint(Constraint)

返回值

constraint(Constraint)

与被调用约束相同的约束。

创建此约束的新实例。

does_advance

< >

( token_id: int )

读取一个 token 并返回它是否创建进度。

remaining

< >

( )

返回为了完成此约束,advance() 还需要多少步。

reset

< >

( )

将此约束的状态重置为其初始化状态。 当约束的满足被不需要的 token 中断时,我们会调用此方法。

test

< >

( )

测试此约束是否已正确定义。

update

< >

( token_id: int ) stepped(bool)

返回值

stepped(bool)

此约束是否更接近被满足。 completed(bool): 此约束是否已通过生成此 token 完全满足。 reset (bool): 此约束是否已通过生成此 token 重置其进度。

读取一个 token 并返回指示其进度的布尔值。 此函数将更新此对象的状态,这与 does_advance(self, token_id: int) 不同。

这不是为了测试某个 token 是否会推进进度;而是更新其状态,就好像它已被生成一样。 如果 token_id != 期望的 token,这将变得很重要(请参阅 PhrasalConstraint 中的 else 语句)

class transformers.PhrasalConstraint

< >

( token_ids: List )

参数

  • token_ids (List[int]) — 输出必须生成的 token 的 id。

Constraint 强制输出中包含 token 的有序序列。

class transformers.DisjunctiveConstraint

< >

( nested_token_ids: List )

参数

  • nested_token_ids (List[List[int]]) — 单词列表,其中每个单词都是一个 id 列表。 此约束通过仅生成单词列表中的一个单词来满足。

一个特殊的 Constraint,它通过仅满足几个约束之一来满足。

class transformers.ConstraintListState

< >

( constraints: List )

参数

  • constraints (List[Constraint]) — 必须由 beam scorer 满足的 Constraint 对象列表。

用于 beam scorer 跟踪其通过约束列表进度的类。

advance

< >

( )

要生成的 token 列表,以便我们可以取得进展。 “列表” 并不意味着将完全满足约束的 token 列表。

给定约束 c_i = {t_ij | j == # of tokens},如果我们没有正在进行特定约束 c_i 的过程中,我们将返回

[t_k1 for k in indices of unfulfilled constraints]

如果我们正在进行约束,那么我们返回: [t_ij],其中 i 是正在进行中的约束的索引,j 是约束的下一步。

虽然我们不关心哪个约束首先被满足,但如果我们正在满足约束的过程中,那将是我们唯一返回的约束。

reset

< >

( token_ids: Optional )

token_ids: 用于重置约束进度状态的到目前为止生成的 tokens。

集束搜索 (BeamSearch)

class transformers.BeamScorer

< >

( )

用于所有用于 ~PreTrainedModel.beam_search~PreTrainedModel.beam_sample 的集束评分器的抽象基类。

process

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor **kwargs ) UserDict

参数

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

    索引可以使用任何继承自 PreTrainedTokenizer 的类获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 IDs?

  • next_scores (形状为 (batch_size, 2 * num_beams)torch.FloatTensor) — 顶部 2 * num_beams 个未完成的集束假设的当前分数。
  • next_tokens (形状为 (batch_size, 2 * num_beams)torch.LongTensor) — 与顶部 2 * num_beams 个未完成的集束假设相对应的 tokens 的 input_ids
  • next_indices (形状为 (batch_size, 2 * num_beams)torch.LongTensor) — 集束索引,指示 next_tokens 对应于哪个集束假设。
  • pad_token_id (int, 可选) — 填充 token 的 id。
  • eos_token_id (Union[int, List[int]], 可选) — 序列结束 token 的 id。 可选地,使用列表来设置多个序列结束 token。
  • beam_indices (torch.LongTensor, 可选) — 集束索引,指示每个 token 对应于哪个集束假设。
  • group_index (int, 可选) — 集束组的索引。 与 ~PreTrainedModel.group_beam_search 一起使用。

返回值

UserDict

由上面定义的字段组成的字典

  • next_beam_scores (形状为 (batch_size * num_beams)torch.FloatTensor) — 所有未完成的集束的更新分数。
  • next_beam_tokens (形状为 (batch_size * num_beams)torch.FloatTensor) — 要添加到未完成的 beam_hypotheses 的下一个 tokens。
  • next_beam_indices (形状为 (batch_size * num_beams)torch.FloatTensor) — 集束索引,指示下一个 tokens 应添加到哪个集束。

finalize

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor max_length: int **kwargs ) torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

参数

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

    索引可以使用任何继承自 PreTrainedTokenizer 的类获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 IDs?

  • final_beam_scores (形状为 (batch_size * num_beams)torch.FloatTensor) — 所有未完成的集束的最终分数。
  • final_beam_tokens (形状为 (batch_size * num_beams)torch.FloatTensor) — 要添加到未完成的 beam_hypotheses 的最后一个 tokens。
  • final_beam_indices (形状为 (batch_size * num_beams)torch.FloatTensor) — 集束索引,指示 final_beam_tokens 应添加到哪个集束。
  • pad_token_id (int, 可选) — 填充 token 的 id。
  • eos_token_id (Union[int, List[int]], 可选) — 序列结束 token 的 id。 可选地,使用列表来设置多个序列结束 token。

返回值

torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

生成的序列。如果所有批次由于 eos_token_id 提前完成,则第二个维度(sequence_length)等于 max_length 或更短。

class transformers.BeamSearchScorer

< >

( batch_size: int num_beams: int device: device length_penalty: Optional = 1.0 do_early_stopping: Union = False num_beam_hyps_to_keep: Optional = 1 num_beam_groups: Optional = 1 max_length: Optional = None )

参数

  • batch_size (int) — input_ids 的批次大小,为此并行运行标准集束搜索解码。
  • num_beams (int) — 集束搜索的集束数量。
  • device (torch.device) — 定义将分配 BeamSearchScorer 此实例的设备类型(例如"cpu""cuda")。
  • length_penalty (float, 可选, 默认为 1.0) — 用于基于集束生成的长度的指数惩罚。它作为序列长度的指数应用,而序列长度又用于除以序列的分数。由于分数是序列的对数似然(即负数),因此 length_penalty > 0.0 促进更长的序列,而 length_penalty < 0.0 鼓励更短的序列。
  • do_early_stopping (boolstr, 可选, 默认为 False) — 控制基于集束的方法(如集束搜索)的停止条件。它接受以下值:True,其中当有 num_beams 个完整候选项时生成停止;False,其中应用启发式方法,当不太可能找到更好的候选项时生成停止;"never",其中集束搜索过程仅在不能有更好的候选项时停止(规范集束搜索算法)。
  • num_beam_hyps_to_keep (int, 可选, 默认为 1) — 调用 finalize() 时应返回的集束假设的数量。
  • num_beam_groups (int, 可选, 默认为 1) — 将 num_beams 分成组的数量,以确保不同组的集束之间的多样性。 有关更多详细信息,请参阅 本文
  • max_length (int, optional) — 要生成的序列的最大长度。

BeamScorer 实现标准束搜索解码。

部分改编自 Facebook 的 XLM 束搜索代码

多样化束搜索算法和实现的参考 Ashwin Kalyan 的 DBS 实现

process

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor pad_token_id: Union = None eos_token_id: Union = None beam_indices: Optional = None group_index: Optional = 0 decoder_prompt_len: Optional = 0 )

finalize

< >

( input_ids: LongTensor final_beam_scores: FloatTensor final_beam_tokens: LongTensor final_beam_indices: LongTensor max_length: int pad_token_id: Union = None eos_token_id: Union = None beam_indices: Optional = None decoder_prompt_len: Optional = 0 )

class transformers.ConstrainedBeamSearchScorer

< >

( batch_size: int num_beams: int constraints: List device: device length_penalty: Optional = 1.0 do_early_stopping: Union = False num_beam_hyps_to_keep: Optional = 1 num_beam_groups: Optional = 1 max_length: Optional = None )

参数

  • batch_size (int) — input_ids 的批大小,为其并行运行标准束搜索解码。
  • num_beams (int) — 用于束搜索的束数量。
  • constraints (List[Constraint]) — 正约束列表,表示为 Constraint 对象,必须在生成输出中满足。有关更多信息,应阅读 Constraint 的文档。
  • device (torch.device) — 定义设备类型(例如"cpu""cuda"),将在其上分配 BeamSearchScorer 的此实例。
  • length_penalty (float, optional, defaults to 1.0) — 用于基于束的生成的长度的指数惩罚。它作为序列长度的指数应用,而序列长度又用于除以序列的分数。由于分数是序列的对数似然(即负数),因此 length_penalty > 0.0 促进更长的序列,而 length_penalty < 0.0 鼓励更短的序列。
  • do_early_stopping (boolstr, optional, defaults to False) — 控制基于束的方法(如束搜索)的停止条件。它接受以下值:True,其中当有 num_beams 个完整候选对象时,生成停止;False,其中应用启发式方法,并且当不太可能找到更好的候选对象时,生成停止;"never",其中束搜索过程仅在无法找到更好的候选对象时停止(规范束搜索算法)。
  • num_beam_hyps_to_keep (int, optional, defaults to 1) — 调用 finalize() 时应返回的束假设的数量。
  • num_beam_groups (int, optional, defaults to 1) — 将 num_beams 分成组的数量,以确保不同束组之间的多样性。 有关更多详细信息,请参见 本文
  • max_length (int, optional) — 要生成的序列的最大长度。

BeamScorer 实现受约束的束搜索解码。

process

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor scores_for_all_vocab: FloatTensor pad_token_id: Union = None eos_token_id: Union = None beam_indices: Optional = None decoder_prompt_len: Optional = 0 ) UserDict

参数

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

    可以使用从 PreTrainedTokenizer 继承的任何类来获取索引。 有关详细信息,请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • next_scores (torch.FloatTensor, 形状为 (batch_size, 2 * num_beams)) — 顶部 2 * num_beams 未完成束假设的当前分数。
  • next_tokens (torch.LongTensor, 形状为 (batch_size, 2 * num_beams)) — 对应于顶部 2 * num_beams 未完成束假设的标记的 input_ids
  • next_indices (torch.LongTensor, 形状为 (batch_size, 2 * num_beams)) — 束索引,指示 next_tokens 对应于哪个束假设。
  • scores_for_all_vocab (torch.FloatTensor, 形状为 (batch_size * num_beams, sequence_length)) — 每个束假设的词汇表中所有标记的分数。
  • pad_token_id (int, optional) — 填充标记的 ID。
  • eos_token_id (Union[int, List[int]], optional) — end-of-sequence 令牌的 ID。 可选地,使用列表来设置多个 end-of-sequence 令牌。
  • beam_indices (torch.LongTensor, optional) — Beam 索引,指示每个令牌对应于哪个 beam 假设。
  • decoder_prompt_len (int, optional) — 解码器输入中包含的 prompt 的长度。

返回值

UserDict

由上面定义的字段组成的字典

  • next_beam_scores (形状为 (batch_size * num_beams)torch.FloatTensor) — 所有未完成的集束的更新分数。

  • next_beam_tokens (形状为 (batch_size * num_beams)torch.FloatTensor) — 要添加到未完成的 beam_hypotheses 的下一个 tokens。

  • next_beam_indices (形状为 (batch_size * num_beams)torch.FloatTensor) — 集束索引,指示下一个 tokens 应添加到哪个集束。

finalize

< >

( input_ids: LongTensor final_beam_scores: FloatTensor final_beam_tokens: LongTensor final_beam_indices: LongTensor max_length: int pad_token_id: Union = None eos_token_id: Union = None beam_indices: Optional = None decoder_prompt_len: Optional = 0 )

Streamers

class transformers.TextStreamer

< >

( tokenizer: AutoTokenizer skip_prompt: bool = False **decode_kwargs )

参数

  • tokenizer (AutoTokenizer) — 用于解码令牌的 tokenizer。
  • skip_prompt (bool, optional, 默认为 False) — 是否跳过 .generate() 的 prompt。 例如,对于聊天机器人很有用。
  • decode_kwargs (dict, optional) — 传递给 tokenizer 的 decode 方法的其他关键字参数。

简单的文本 streamer,一旦形成完整的单词,就将令牌打印到 stdout。

streamer 类的 API 仍在开发中,将来可能会发生变化。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextStreamer(tok)

>>> # Despite returning the usual output, the streamer will also print the generated text to stdout.
>>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20)
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,

end

< >

( )

刷新任何剩余的缓存,并向 stdout 打印一个换行符。

on_finalized_text

< >

( text: str stream_end: bool = False )

将新文本打印到 stdout。 如果流正在结束,还会打印一个换行符。

put

< >

( value )

接收令牌,解码它们,并在它们形成完整的单词后立即将它们打印到 stdout。

class transformers.TextIteratorStreamer

< >

( tokenizer: AutoTokenizer skip_prompt: bool = False timeout: Optional = None **decode_kwargs )

参数

  • tokenizer (AutoTokenizer) — 用于解码令牌的 tokenizer。
  • skip_prompt (bool, optional, 默认为 False) — 是否跳过 .generate() 的 prompt。 例如,对于聊天机器人很有用。
  • timeout (float, optional) — 文本队列的超时时间。 如果为 None,队列将无限期阻塞。 当在单独的线程中调用 .generate() 时,这对于处理异常很有用。
  • decode_kwargs (dict, optional) — 传递给 tokenizer 的 decode 方法的其他关键字参数。

Streamer,将准备打印的文本存储在队列中,供下游应用程序用作迭代器。 这对于那些受益于以非阻塞方式访问生成文本的应用程序(例如,在交互式 Gradio 演示中)非常有用。

streamer 类的 API 仍在开发中,将来可能会发生变化。

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
>>> from threading import Thread

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextIteratorStreamer(tok)

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
>>> thread = Thread(target=model.generate, kwargs=generation_kwargs)
>>> thread.start()
>>> generated_text = ""
>>> for new_text in streamer:
...     generated_text += new_text
>>> generated_text
'An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,'

on_finalized_text

< >

( text: str stream_end: bool = False )

将新文本放入队列中。 如果流正在结束,还会将停止信号放入队列中。

Caches

class transformers.Cache

< >

( )

所有缓存的基类、抽象类。 实际的数据结构特定于每个子类。

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新 key 状态。
  • value_states (torch.Tensor) — 要缓存的新 value 状态。
  • layer_idx (int) — 要缓存状态的层的索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的其他参数。 这些参数特定于每个子类,并允许创建新型缓存。

为层 layer_idx 更新具有新的 key_statesvalue_states 的缓存。

class transformers.CacheConfig

< >

( cache_implementation: None )

缓存配置的基类

update

< >

( **kwargs ) Dict[str, Any]

参数

  • kwargs (Dict[str, Any]) — 尝试使用此类中的属性更新的属性字典。

返回值

Dict[str, Any]

包含所有未用于更新实例的键值对的字典。

如果 kwargs 中的属性与现有属性匹配,则使用这些属性更新此类实例,并返回所有未使用的 kwargs。

class transformers.QuantizedCacheConfig

< >

( backend: str = 'quanto' nbits: Optional = 4 axis_key: Optional = 0 axis_value: Optional = 0 q_group_size: Optional = 64 residual_length: Optional = 128 compute_dtype: Optional = torch.float16 device: Optional = 'cpu' )

参数

  • backend (str, 可选,默认为 "quanto") — 执行量化时使用的后端,可以是 [quanto, HQQ] 之一
  • nbits (Optional[int], 可选,默认为 4) — 位数,对于 quanto 后端可以是 2 或 4,对于 HQQ 后端可以是 [1, 2, 3, 4, 8] 之一。默认为 2。
  • axis_key (int, 可选,默认为 0) — 对键张量执行分组的轴。对于 quanto 后端可以是 [0, -1],对于 HQQ 后端可以是 [0, 1]。
  • axis_value (int, 可选,默认为 0) — 对值张量执行分组的轴。对于 quanto 后端可以是 [0, -1],对于 HQQ 后端可以是 [0, 1]。
  • q_group_size (Optional[int], 可选,默认为 64) — 量化组的大小,应为模型隐藏层维度的除数。默认为 64。
  • residual_length (Optional[int], 可选,默认为 128) — 残差缓存的长度,该缓存将始终以原始精度存储。默认为 128。
  • compute_dtype (torch.dtype, 可选,默认为 torch.float16) — 模型中计算使用的默认数据类型。键和值在反量化后将转换为此数据类型。
  • device (str, 可选,默认为 "cpu") — 执行计算的设备,应与模型的设备相同。

量化缓存设置的配置类。

validate

< >

( )

验证传递的参数是否正确

class transformers.DynamicCache

< >

( num_hidden_layers: Optional = None )

一种随着生成更多 token 而动态增长的缓存。这是生成模型的默认设置。

它将 Key 和 Value 状态存储为张量列表,每层一个张量。每个张量的预期形状为 [batch_size, num_heads, seq_len, head_dim]

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, DynamicCache

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> past_key_values = DynamicCache()
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
DynamicCache()

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新键状态。
  • value_states (torch.Tensor) — 要缓存的新值状态。
  • layer_idx (int) — 要缓存状态的层索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的其他参数。DynamicCache 中未使用其他参数。

为层 layer_idx 更新具有新的 key_statesvalue_states 的缓存。

get_seq_length

< >

( layer_idx: Optional = 0 )

返回缓存状态的序列长度。可以选择性地传递层索引。

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的 beam 索引,为 beam search 重新排序缓存。

to_legacy_cache

< >

( )

DynamicCache 实例转换为其在旧式缓存格式中的等效形式。用于向后兼容。

from_legacy_cache

< >

( past_key_values: Optional = None num_hidden_layers: int = None )

将旧式缓存格式的缓存转换为等效的 DynamicCache。用于向后兼容。

class transformers.QuantizedCache

< >

( cache_config: QuantizedCacheConfig )

类似于 KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache 论文 中描述的量化器缓存。它允许模型生成更长的序列长度,而无需为 Key 和 Value 缓存分配过多内存,通过应用量化来实现。

缓存有两种类型的存储,一种用于原始精度,另一种用于量化缓存。residual length 被设置为原始精度缓存的最大容量。当长度超过最大容量时,原始精度缓存将被丢弃并移动到量化缓存中。与论文中描述的不同,量化是针对 Key 和 Value 的每个通道完成的,并设置了 q_group_size

它将 Keys 和 Values 存储为量化张量(如果需要存储元数据,则为元组)的列表,每层一个。此外,它还将原始精度状态的 Key 和 Value 存储为张量列表,每层一个。每个张量的大小为 [batch_size, num_heads, seq_len - residual_length, head_dim]

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

get_seq_length

< >

( layer_idx: Optional = 0 )

返回缓存状态的序列长度。可以选择性地传递层索引。

class transformers.QuantoQuantizedCache

< >

( cache_config: CacheConfig )

参数

  • cache_config (QuantizedCacheConfig) — 包含量化器使用的所有参数的配置,包括轴,qtype 和组大小。

量化缓存类,使用 quanto 作为后端执行量化。当前实现仅支持 int2int4 数据类型。

示例

>>> # Run pip install quanto first if you don't have it yet
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, QuantoQuantizedCache, QuantizedCacheConfig

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> cache_config = QuantizedCacheConfig(nbits=4)
>>> past_key_values = QuantoQuantizedCache(cache_config=cache_config)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
QuantoQuantizedCache()

class transformers.HQQQuantizedCache

< >

( cache_config: CacheConfig )

参数

  • cache_config (QuantizedCacheConfig) — 包含量化器使用的所有参数的配置,包括轴,qtype 和组大小。

量化缓存类,使用 HQQ 作为后端执行量化。当前实现支持 int2, int4, int8 数据类型。

示例

>>> # Run pip install hqq first if you don't have it yet
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, HQQQuantizedCache, QuantizedCacheConfig

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> cache_config = QuantizedCacheConfig(nbits=4, axis_key=1, axis_value=1)
>>> past_key_values = HQQQuantizedCache(cache_config=cache_config)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
HQQQuantizedCache()

class transformers.SinkCache

< >

( window_length: int num_sink_tokens: int )

参数

  • window_length (int) — 上下文窗口的长度。
  • num_sink_tokens (int) — sink 令牌的数量。有关更多信息,请参阅原始论文。

Attention Sinks 论文 中所述的缓存。它允许模型生成超出其上下文窗口长度的内容,而不会失去对话的流畅性。由于它丢弃了过去的令牌,模型将失去生成依赖于已丢弃上下文的令牌的能力。

它将 Key 和 Value 状态存储为张量列表,每层一个张量。每个张量的预期形状为 [batch_size, num_heads, seq_len, head_dim]

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, SinkCache

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> past_key_values = SinkCache(window_length=256, num_sink_tokens=4)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
SinkCache()

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新键状态。
  • value_states (torch.Tensor) — 要缓存的新值状态。
  • layer_idx (int) — 要缓存状态的层的索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的附加参数。以下参数可以在 SinkCache 中使用:sin, cospartial_rotation_size。这些参数与使用 RoPE 的模型一起使用,以在令牌移动时重新计算旋转。

为层 layer_idx 更新具有新的 key_statesvalue_states 的缓存。

get_seq_length

< >

( layer_idx: Optional = 0 )

返回缓存状态的序列长度。可以选择性地传递层索引。

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的 beam 索引,为 beam search 重新排序缓存。

class transformers.OffloadedCache

< >

( )

DynamicCache 的直接替代品,以增加 CPU 内存为代价来节省 GPU 内存。适用于从具有超长上下文的模型中生成内容。

除了所有 forward() 计算发生的默认 CUDA 流之外,此类还使用另一个流,即预取流,它自行创建。由于在单独的流上进行操作调度是独立发生的,因此当第 k 层正在执行时,此类使用预取流来异步预取第 k+1 层的 KV 缓存。第 k-1 层缓存到 CPU 的移动由默认流处理,这是一种确保在完成该缓存上的所有计算后调度驱逐的简单方法。

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新键状态。
  • value_states (torch.Tensor) — 要缓存的新值状态。
  • layer_idx (int) — 要缓存状态的层的索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的附加参数。OffloadedCache 中没有使用其他参数。

为层 layer_idx 更新具有新的 key_statesvalue_states 的缓存。

prefetch_layer

< >

( layer_idx: int )

开始预取下一层缓存

evict_previous_layer

< >

( layer_idx: int )

将上一层缓存移动到 CPU

class transformers.StaticCache

< >

( config: PretrainedConfig batch_size: int = None max_cache_len: int = None device: device = None dtype: dtype = torch.float32 max_batch_size: Optional = None layer_device_map: Optional = None )

参数

  • config (PretrainedConfig) — 配置文件,用于定义初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批处理大小。请注意,如果使用较小的批处理大小,则必须实例化新的实例。 如果您是手动设置批处理大小,请确保考虑在运行 beam 搜索时 beam 的数量
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (torch.device or str) — 缓存应在其上初始化的设备。应与层相同。
  • dtype (torch.dtype, optional, defaults to torch.float32) — 初始化层时使用的默认 dtype,默认为 torch.float32
  • layer_device_map(`Dict[int, Union[str, torch.device, int]]], optional) -- 层与其设备的映射。当您手动初始化缓存并且模型在不同的 gpus 之间分割时,这是必需的。您可以通过检查关联的 device_map 来了解哪些层映射到哪个设备:model.hf_device_map`。

静态缓存类,用于 torch.compile(model)torch.export()

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, StaticCache

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")

>>> inputs = tokenizer(text="My name is Llama", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = StaticCache(config=model.config, batch_size=1, max_cache_len=max_generated_length, device=model.device, dtype=model.dtype)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
StaticCache()

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新 key 状态。
  • value_states (torch.Tensor) — 要缓存的新 value 状态。
  • layer_idx (int) — 要缓存状态的层索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的其他参数。 StaticCache 需要 cache_position 输入来确定在缓存中写入的位置。

使用新的 key_statesvalue_states 更新 layer_idx 层的缓存。 使用张量进行索引非常重要,否则会将副本引入设备。

get_seq_length

< >

( layer_idx: Optional = 0 )

返回模型所见缓存状态的序列长度。

reset

< >

( )

重置缓存值,同时保留对象。

class transformers.OffloadedStaticCache

< >

( config: PretrainedConfig max_batch_size: int max_cache_len: Optional device: Union dtype: Optional = None offload_device: Union = device(type='cpu') )

参数

  • config (PretrainedConfig) — 配置文件,定义初始化静态缓存所需的形状相关属性。
  • max_batch_size (int) — 模型将使用的最大批次大小。
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (Union[str, torch.device]) — 缓存应在其上初始化的设备。应与层设备相同。
  • dtype (torch.dtype, optional) — 初始化缓存时使用的默认 dtype
  • offload_device (Union[str, torch.device], optional, defaults to cpu) — 卸载到的设备。 默认为 CPU。
  • key_cache (List[torch.Tensor]) — 卸载的 key 缓存张量列表。第一个将在设备上,而其他的将被卸载。
  • value_cache (List[torch.Tensor]) — 卸载的 value 缓存张量列表。第一个将在设备上,而其他的将被卸载。
  • max_batch_size (int) — 此缓存可使用的最大批次大小。
  • max_cache_len (int) — 此缓存可使用的最大序列长度。
  • device (torch.device) — 缓存使用的设备。
  • offload_device (torch.device) — 用于卸载的设备。
  • dtype (torch.dtype) — 用于初始化缓存的 dtype

静态缓存类,用于 torch.compile(model),可卸载到 CPU 或其他设备。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, OffloadedStaticCache

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> inputs = tokenizer(text="My name is GPT2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = OffloadedStaticCache(config=model.config, max_batch_size=1, max_cache_len=max_generated_length, device=model.device, dtype=model.dtype)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> past_kv_length = outputs.past_key_values # access cache filled with key/values from generation

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

参数

  • key_states (torch.Tensor) — 要缓存的新 key 状态。
  • value_states (torch.Tensor) — 要缓存的新 value 状态。
  • layer_idx (int) — 要缓存状态的层索引。
  • cache_kwargs (Dict[str, Any], optional) — 缓存子类的其他参数。 OffloadedStaticCache 需要 cache_position 输入来确定在缓存中写入的位置。

使用新的 key_statesvalue_states 更新 layer_idx 层的缓存。 使用张量进行索引非常重要,否则会将副本引入设备。

get_seq_length

< >

( layer_idx: Optional = 0 )

返回模型所见缓存状态的序列长度。

reset

< >

( )

重置缓存值,同时保留对象。

class transformers.HybridCache

< >

( config: PretrainedConfig batch_size: int = None max_cache_len: int = None device: Union = 'cpu' dtype: dtype = torch.float32 max_batch_size: Optional = None layer_device_map: Optional = None )

参数

  • config (PretrainedConfig) — 配置文件,定义初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批次大小。 请注意,如果使用较小的批次大小,则必须实例化一个新实例。
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (torch.devicestr, 可选, 默认为 "cpu") — 缓存应初始化的设备。应与层相同。
  • dtype (torch.dtype, 可选, 默认为 torch.float32) — 初始化层时使用的默认 dtype
  • layer_device_map(`Dict[int, Union[str, torch.device, int]]], optional) -- 层与其设备的映射。 当您手动初始化缓存并且模型在不同的 GPU 之间拆分时,这是必需的。 您可以通过检查相关的 device_map 来了解哪些层映射到哪个设备:model.hf_device_map`。

用于 Gemma2 模型的混合缓存类,该模型在每隔一层中的本地滑动窗口注意力机制和全局注意力机制之间交替。 在底层,混合缓存利用 [“SlidingWindowCache”] 进行滑动窗口注意力机制,并利用 [“StaticCache”] 进行全局注意力机制。 有关更多信息,请参阅每个子组件缓存类的文档。

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, HybridCache

>>> model = AutoModelForCausalLM.from_pretrained("google/gemma-2-2b")
>>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b")

>>> inputs = tokenizer(text="My name is Gemma", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = HybridCache(config=model.config, batch_size=1, max_cache_len=max_generated_length, device=model.device, dtype=model.dtype)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
HybridCache()

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

get_seq_length

< >

( layer_idx: Optional = 0 )

reset

< >

( )

重置缓存值,同时保留对象。

class transformers.SlidingWindowCache

< >

( config: PretrainedConfig batch_size: int = None max_cache_len: int = None device: device = None dtype: dtype = torch.float32 max_batch_size: Optional = None layer_device_map: Optional = None )

参数

  • config (PretrainedConfig) — 配置文件,用于定义初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批次大小。 请注意,如果使用较小的批次大小,则必须实例化一个新实例。
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (torch.devicestr) — 缓存应初始化的设备。应与层相同。
  • dtype (torch.dtype, 可选, 默认为 torch.float32) — 初始化层时使用的默认 dtype
  • layer_device_map(`Dict[int, Union[str, torch.device, int]]], optional) -- 层与其设备的映射。 当您手动初始化缓存并且模型在不同的 GPU 之间拆分时,这是必需的。 您可以通过检查相关的 device_map 来了解哪些层映射到哪个设备:model.hf_device_map`。

滑动窗口缓存类,用于支持滑动窗口注意力机制(如 Mistral)的模型与 torch.compile 一起使用。 每次我们尝试更新缓存时,我们都会基于 cache_position >= self.config.sliding_window - 1 计算 indices,如果为 true(这意味着由于滑动窗口约束,缓存无法同时容纳所有旧的键值状态和新状态),我们需要基于 indices 进行循环移位,以将最旧的状态替换为传入的新键值状态。

只有当我们超出 sliding_window 时,to_shift 才为真。 因此,对于 sliding_window==64

indices = (slicing + to_shift[-1].int()-1) % self.config.sliding_window tensor([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0])

我们使用这些覆盖缓存,然后我们始终在 cache_position(钳制到 sliding_window)处写入

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, SlidingWindowCache

>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")

>>> inputs = tokenizer(text="My name is Mistral", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = SlidingWindowCache(config=model.config, batch_size=1, max_cache_len=max_generated_length, device=model.device, dtype=model.dtype)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
SlidingWindowCache()

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: Optional = None )

reset

< >

( )

class transformers.EncoderDecoderCache

< >

( self_attention_cache: Cache cross_attention_cache: Cache )

所有编码器-解码器缓存的基类,抽象类。 可用于保存自注意力缓存和交叉注意力缓存的组合。

示例

>>> from transformers import AutoProcessor, AutoModelForCausalLM, DynamicCache, EncoderDecoderCache

>>> model = AutoModelForCausalLM.from_pretrained("openai/whisper-small")
>>> processor = AutoProcessor.from_pretrained("openai/whisper-small")

>>> inputs = processor(audio=YOUR-AUDIO, return_tensors="pt")

>>> # Prepare cache classes for encoder and decoder and pass it to model's forward
>>> self_attention_cache = DynamicCache()
>>> cross_attention_cache = DynamicCache()
>>> past_key_values = EncoderDecoderCache(self_attention_cache, cross_attention_cache)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
EncoderDecoderCache()

get_seq_length

< >

( layer_idx: Optional = 0 )

返回缓存状态的序列长度。可以选择性地传递层索引。

to_legacy_cache

< >

( )

EncoderDecoderCache 实例转换为旧版缓存格式的等效实例。

from_legacy_cache

< >

( past_key_values: Optional = None )

将旧版缓存格式的缓存转换为等效的 EncoderDecoderCache

reset

< >

( )

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的 beam 索引,为 beam search 重新排序缓存。

class transformers.MambaCache

< >

( config: PretrainedConfig batch_size: int = None dtype: dtype = torch.float16 device: Union = None max_batch_size: Optional = None )

参数

  • config (`PretrainedConfig) — 配置文件,用于定义初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批次大小。 请注意,如果使用较小的批次大小,则必须实例化一个新实例。
  • dtype (torch.dtype, 可选, 默认为 torch.float16) — 初始化层时使用的默认 dtype
  • device (torch.device or str, optional) — 缓存应初始化的设备。应与层相同。 dtype — (torch.dtype): 用于初始化缓存的默认 dtype。 intermediate_size — (int): 从配置中获取的模型 intermediate_size。 ssm_state_size — (int): 从配置中获取的模型 state_size。 conv_kernel_size — (int): 从配置中获取的模型卷积核大小 conv_states — (torch.Tensor): 形状为 [layer_idx, batch_size, intermediate_size, conv_kernel_size] 的张量,用于保存卷积状态。 ssm_states — (torch.Tensor): 形状为 [layer_idx, batch_size, intermediate_size, ssm_state_size] 的张量,用于保存 ssm 状态

用于 mamba 模型的缓存,该模型没有注意力机制和键值状态。

示例

>>> from transformers import AutoTokenizer, MambaForCausalLM, MambaCache

>>> model = MambaForCausalLM.from_pretrained("state-spaces/mamba-130m-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("state-spaces/mamba-130m-hf")

>>> inputs = tokenizer(text="My name is Mamba", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> past_key_values = MambaCache(config=model.config, batch_size=1, device=model.device, dtype=model.dtype)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values
MambaCache()

update_conv_state

< >

( layer_idx: int new_conv_state: Tensor cache_position: LongTensor )

update_ssm_state

< >

( layer_idx: int new_ssm_state: Tensor )

reset

< >

( )

水印工具

class transformers.WatermarkDetector

< >

( model_config: PretrainedConfig device: str watermarking_config: Union ignore_repeated_ngrams: bool = False max_cache_size: int = 128 )

参数

  • model_config (PretrainedConfig) — 将用于获取生成时使用的模型特定参数的模型配置。
  • device (str) — 水印文本生成期间使用的设备。
  • watermarking_config (Union[WatermarkingConfig, Dict]) — 生成文本时使用的完全相同的水印配置和参数。
  • ignore_repeated_ngrams (bool, optional, defaults to False) — 是否仅对每个唯一的 ngram 计数一次。
  • max_cache_size (int, optional, defaults to 128) — 用于 LRU 缓存的最大大小,用于每次 token 调用 seeding/sampling 算法。

用于检测水印生成文本的检测器。检测器需要提供与文本生成期间提供的完全相同的设置,以复制水印绿名单生成,从而检测水印。这包括文本生成期间使用的正确设备、正确的水印参数和正确的 tokenizer 词汇表大小。该代码基于 原始仓库

有关更多信息,请参阅 论文

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig

>>> model_id = "openai-community/gpt2"
>>> model = AutoModelForCausalLM.from_pretrained(model_id)
>>> tok = AutoTokenizer.from_pretrained(model_id)
>>> tok.pad_token_id = tok.eos_token_id
>>> tok.padding_side = "left"

>>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt")
>>> input_len = inputs["input_ids"].shape[-1]

>>> # first generate text with watermark and without
>>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash")
>>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20)
>>> out = model.generate(**inputs, do_sample=False, max_length=20)

>>> # now we can instantiate the detector and check the generated text
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config)
>>> detection_out_watermarked = detector(out_watermarked, return_dict=True)
>>> detection_out = detector(out, return_dict=True)
>>> detection_out_watermarked.prediction
array([ True,  True])

>>> detection_out.prediction
array([False,  False])

__call__

< >

( input_ids: LongTensor z_threshold: float = 3.0 return_dict: bool = False ) WatermarkDetectorOutput or np.array

参数

  • input_ids (torch.LongTensor) — 水印生成的文本。建议删除提示,这可能会影响检测。
  • z_threshold (Dict, optional, defaults to 3.0) — 更改此阈值将更改检测器的灵敏度。较高的 z 阈值灵敏度较低,而较低的 z 阈值灵敏度较高。
  • return_dict (bool, optional, defaults to False) — 是否返回 ~generation.WatermarkDetectorOutput。如果不是,它将返回布尔值预测,

返回值

WatermarkDetectorOutput or np.array

如果 return_dict=True,则为 WatermarkDetectorOutput,否则为 np.array

ma

< > 更新 on GitHub