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:生成的 token 序列
  • 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: typing.Optional[typing.Tuple[torch.FloatTensor]] = None logits: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[typing.Tuple[torch.FloatTensor]]]] = None )

参数

  • sequences (形状为 (batch_size, sequence_length)torch.LongTensor) — 生成的序列。第二个维度 (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 一个元素),其中包含元组(解码器的每一层一个元素),包含形状为 (batch_size, num_heads, generated_length, sequence_length)torch.FloatTensor
  • hidden_states (tuple(tuple(torch.FloatTensor)), 可选,当 output_hidden_states=True 时返回) — 元组(每个生成的 token 一个元素),其中包含元组(解码器的每一层一个元素),包含形状为 (batch_size, generated_length, hidden_size)torch.FloatTensor
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选,当 use_cache=True 时返回) — 返回模型缓存,用于加速解码。不同的模型具有不同的缓存格式,请查看模型的文档。通常是 Cache 实例。

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

class transformers.generation.GenerateEncoderDecoderOutput

< >

( sequences: LongTensor = None scores: typing.Optional[typing.Tuple[torch.FloatTensor]] = None logits: typing.Optional[typing.Tuple[torch.FloatTensor]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[typing.Tuple[torch.FloatTensor]]]] = None )

参数

  • sequences (形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor) — 生成的序列。第二个维度 (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)
  • 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, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(torch.FloatTensor)), optional, returned when output_attentions=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size, num_heads, generated_length, sequence_length)torch.FloatTensor
  • cross_attentions (tuple(tuple(torch.FloatTensor)), optional, returned when output_attentions=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size, num_heads, generated_length, sequence_length)torch.FloatTensor
  • decoder_hidden_states (tuple(tuple(torch.FloatTensor)), optional, returned when output_hidden_states=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size, generated_length, hidden_size)torch.FloatTensor
  • past_key_values (tuple(tuple(torch.FloatTensor))), optional, returned when use_cache=True is passed or when config.use_cache=True) — 返回模型缓存,用于加速解码。不同模型有不同的缓存格式,请查看模型的文档。通常是一个 Cache 实例。

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

class transformers.generation.GenerateBeamDecoderOnlyOutput

< >

( sequences: LongTensor = None sequences_scores: typing.Optional[torch.FloatTensor] = None scores: typing.Optional[typing.Tuple[torch.FloatTensor]] = None logits: typing.Optional[typing.Tuple[torch.FloatTensor]] = None beam_indices: typing.Optional[torch.LongTensor] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[typing.Tuple[torch.FloatTensor]]]] = None )

参数

  • sequences (torch.LongTensor of shape (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 提前结束。
  • sequences_scores (torch.FloatTensor of shape (batch_size*num_return_sequences), optional, returned when output_scores=True) — 生成的 sequences 的最终 beam scores。
  • scores (tuple(torch.FloatTensor) optional, returned when output_scores=True) — 每个生成步骤中每个词汇表 token 的 Beam transition scores。Beam transition scores 由 tokens 的 log probabilities 组成,这些概率以该 beam 中先前生成的 tokens 的 log softmax 为条件。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • logits (tuple(torch.FloatTensor) optional, returned when output_logits=True) — 语言建模头的未处理预测 scores(SoftMax 之前每个词汇表 token 的 scores)在每个生成步骤。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • beam_indices (torch.LongTensor, optional, returned when output_scores=True) — 每个生成步骤中生成的 token id 的 Beam indices。形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor
  • attentions (tuple(tuple(torch.FloatTensor)), optional, returned when output_attentions=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)torch.FloatTensor
  • hidden_states (tuple(tuple(torch.FloatTensor)), optional, returned when output_hidden_states=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size)torch.FloatTensor
  • past_key_values (tuple(tuple(torch.FloatTensor))), optional, returned when use_cache=True) — 返回模型缓存,用于加速解码。不同模型有不同的缓存格式,请查看模型的文档。通常是一个 Cache 实例。

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

class transformers.generation.GenerateBeamEncoderDecoderOutput

< >

( sequences: LongTensor = None sequences_scores: typing.Optional[torch.FloatTensor] = None scores: typing.Optional[typing.Tuple[torch.FloatTensor]] = None logits: typing.Optional[typing.Tuple[torch.FloatTensor]] = None beam_indices: typing.Optional[torch.LongTensor] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[typing.Tuple[torch.FloatTensor]]]] = None )

参数

  • sequences (torch.LongTensor of shape (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 提前结束。
  • sequences_scores (torch.FloatTensor of shape (batch_size*num_return_sequences), optional, returned when output_scores=True) — 生成的 sequences 的最终 beam scores。
  • scores (tuple(torch.FloatTensor) optional, returned when output_scores=True) — 每个生成步骤中每个词汇表 token 的 Beam transition scores。Beam transition scores 由 tokens 的 log probabilities 组成,这些概率以该 beam 中先前生成的 tokens 的 log softmax 为条件。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • logits (tuple(torch.FloatTensor) optional, returned when output_logits=True) — 语言建模头的未处理预测 scores(SoftMax 之前每个词汇表 token 的 scores)在每个生成步骤。torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • beam_indices (torch.LongTensor, optional, returned when output_scores=True) — 每个生成步骤中生成的 token id 的 Beam indices。形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor
  • encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True) — torch.FloatTensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True) — torch.FloatTensor 的元组(embeddings 的输出 + 每一层输出),形状为 (batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(torch.FloatTensor)), optional, returned when output_attentions=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)torch.FloatTensor
  • cross_attentions (tuple(tuple(torch.FloatTensor)), optional, returned when output_attentions=True) — 元组(每个生成的 token 一个元素),包含元组(解码器每一层一个元素),元素为形状为 (batch_size, num_heads, generated_length, sequence_length)torch.FloatTensor
  • decoder_hidden_states (tuple(tuple(torch.FloatTensor)), optional, returned when output_hidden_states=True) — 元组 (为每个生成的 token 提供一个元素),其中元素也是元组 (为解码器的每一层提供一个元素),内层元组的元素是 torch.FloatTensor,形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size)
  • past_key_values (tuple(tuple(torch.FloatTensor))), optional, returned when use_cache=True) — 返回模型缓存,用于加速解码。不同模型的缓存格式不同,请查看模型的文档。通常是一个 Cache 实例。

编码器-解码器生成模型的输出,当使用 beam 方法时返回。

TensorFlow

class transformers.generation.TFGreedySearchEncoderDecoderOutput

< >

( sequences: Tensor = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

  • sequences (tf.Tensor,形状为 (batch_size, sequence_length)) — 生成的序列。第二个维度(sequence_length)要么等于 max_length,要么更短,如果所有批次由于 eos_token_id 而提前结束。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言模型头的处理后的预测分数(每个生成步骤中,SoftMax 之前的每个词汇 token 的分数)。tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个 tensor 的形状为 (batch_size, config.vocab_size)
  • encoder_attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 的元组(embeddings 的输出 + 每一层的输出各一个),形状为 (batch_size, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), optional, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组 (为每个生成的 token 提供一个元素),其中元素也是元组 (为解码器的每一层提供一个元素),内层元组的元素是 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • cross_attentions (tuple(tuple(tf.Tensor)), optional, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组 (为每个生成的 token 提供一个元素),其中元素也是元组 (为解码器的每一层提供一个元素),内层元组的元素是 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length)
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), optional, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组 (为每个生成的 token 提供一个元素),其中元素也是元组 (为解码器的每一层提供一个元素),内层元组的元素是 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: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

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

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

class transformers.generation.TFSampleEncoderDecoderOutput

< >

( sequences: Tensor = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

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

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

class transformers.generation.TFSampleDecoderOnlyOutput

< >

( sequences: Tensor = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

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

class transformers.generation.TFBeamSearchEncoderDecoderOutput

< >

( sequences: Tensor = None sequences_scores: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None beam_indices: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None encoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

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

class transformers.generation.TFBeamSearchDecoderOnlyOutput

< >

( sequences: Tensor = None sequences_scores: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None beam_indices: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

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

class transformers.generation.TFBeamSampleEncoderDecoderOutput

< >

( sequences: Tensor = None sequences_scores: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None beam_indices: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None encoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

  • sequences (tf.Tensor of shape (batch_size*num_beams, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前结束)。
  • sequences_scores (tf.Tensor of shape (batch_size * num_return_sequence), optional, returned when output_scores=True is passed or when config.output_scores=True) — 生成的 sequences 的最终束搜索得分。
  • scores (tuple(tf.Tensor) optional, returned when output_scores=True is passed or when config.output_scores=True) — 每个生成步骤中每个词汇标记的处理束搜索得分。束搜索得分由每个词汇标记的 log softmax 得分以及此束中先前生成的标记的 log softmax 总和组成。tf.Tensor 元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size)
  • beam_indices (tf.Tensor, optional, returned when output_scores=True is passed or when config.output_scores=True) — 每个生成步骤中生成的标记 id 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or config.output_attentions=True) — tf.Tensor 元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 元组(嵌入输出 + 每层输出各一个),形状为 (batch_size*num_beams, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), optional, returned when output_attentions=True is passed or config.output_attentions=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)tf.Tensor
  • cross_attentions (tuple(tuple(tf.Tensor)), optional, returned when output_attentions=True is passed or config.output_attentions=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size*num_beams, generated_length, hidden_size)tf.Tensor

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

class transformers.generation.TFBeamSampleDecoderOnlyOutput

< >

( sequences: Tensor = None sequences_scores: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None beam_indices: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

  • sequences (tf.Tensor of shape (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前结束)。
  • sequences_scores (tf.Tensor of shape (batch_size * num_return_sequence), optional, returned when output_scores=True is passed or when config.output_scores=True) — 生成的 sequences 的最终束搜索得分。
  • scores (tuple(tf.Tensor) optional, returned when output_scores=True is passed or when config.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, optional, returned when output_scores=True is passed or when config.output_scores=True) — 每个生成步骤中生成的标记 id 的束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor
  • attentions (tuple(tuple(tf.Tensor)), optional, returned when output_attentions=True is passed or config.output_attentions=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length)tf.Tensor
  • hidden_states (tuple(tuple(tf.Tensor)), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size*num_beams, generated_length, hidden_size)tf.Tensor

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

class transformers.generation.TFContrastiveSearchEncoderDecoderOutput

< >

( sequences: Tensor = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None encoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None decoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None cross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None )

参数

  • sequences (tf.Tensor of shape (batch_size, sequence_length)) — 生成的序列。第二个维度 (sequence_length) 要么等于 max_length,要么更短(如果所有批次由于 eos_token_id 而提前结束)。
  • scores (tuple(tf.Tensor) optional, returned when output_scores=True is passed or when config.output_scores=True) — 每个生成步骤中语言建模头的处理预测得分(SoftMax 之前每个词汇标记的得分)。tf.Tensor 元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or config.output_attentions=True) — tf.Tensor 元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)
  • encoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 元组(嵌入输出 + 每层输出各一个),形状为 (batch_size, sequence_length, hidden_size)
  • decoder_attentions (tuple(tuple(tf.Tensor)), optional, returned when output_attentions=True is passed or config.output_attentions=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • cross_attentions (tuple(tuple(tf.Tensor)), optional, returned when output_attentions=True is passed or config.output_attentions=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组(每个生成的标记一个元素),包含元组(解码器的每一层一个元素),其中的元素是形状为 (batch_size, generated_length, hidden_size)tf.Tensor

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

class transformers.generation.TFContrastiveSearchDecoderOnlyOutput

< >

( sequences: Tensor = None scores: typing.Optional[typing.Tuple[tensorflow.python.framework.tensor.Tensor]] = None attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = None hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.tensor.Tensor]]] = 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 时返回) — 语言建模头的处理后的预测分数(每个生成步骤中每个词汇表 token 的 SoftMax 之前的分数)。tf.Tensor 元组,最多包含 max_new_tokens 个元素(每个生成的 token 一个元素),每个张量的形状为 (batch_size, config.vocab_size)
  • attentions (tuple(tuple(tf.Tensor)), 可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的 token 一个元素),包含元组(解码器的每一层一个元素),元素为形状为 (batch_size, num_heads, generated_length, sequence_length)tf.Tensor
  • hidden_states (tuple(tuple(tf.Tensor)), 可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的 token 一个元素),包含元组(解码器的每一层一个元素),元素为形状为 (batch_size, generated_length, hidden_size)tf.Tensor

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

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) 的引导尺度。CFG 通过设置 guidance_scale > 1 启用。较高的引导尺度鼓励模型生成与输入提示更紧密相关的样本,但通常以牺牲较差的质量为代价。

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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EncoderRepetitionPenaltyLogitsProcessor

< >

( penalty: float encoder_input_ids: LongTensor )

参数

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

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

它旨在避免输入接地的任务(如摘要)中的幻觉。虽然最初是为编码器-解码器模型设计的,但它也可以与仅解码器模型(如 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.EpsilonLogitsWarper

< >

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

参数

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

LogitsProcessor,执行 epsilon 采样,即限制为概率 prob >= epsilon 的 tokens。如果没有任何 tokens 满足此约束,则取最大的 min_tokens_to_keep 个 tokens。有关更多信息,请参阅 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (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") — 用于分配张量的设备。

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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ExponentialDecayLengthPenalty

< >

( exponential_decay_length_penalty: typing.Tuple[int, float] eos_token_id: typing.Union[int, typing.List[int], torch.Tensor] 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

LogitsProcessor,强制将指定的 token 作为第一个生成的 token。与编码器-解码器模型一起使用。

示例

>>> 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.ForcedEOSTokenLogitsProcessor

< >

( max_length: int eos_token_id: typing.Union[int, typing.List[int], torch.Tensor] device: str = 'cpu' )

参数

  • max_length (int) — 要生成的序列的最大长度。
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 序列结束 token 的 ID。
  • device (str, optional, defaults to "cpu") — 分配 tensors 的设备,默认为 "cpu"

LogitsProcessor,强制将指定的 token 作为达到 max_length 时的最后一个生成的 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.HammingDiversityLogitsProcessor

< >

( diversity_penalty: float num_beams: int num_beam_groups: int )

参数

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

LogitsProcessor,强制执行多样化的束搜索。

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

传统的束搜索通常在不同的 beams 之间生成非常相似的序列。HammingDiversityLogitsProcessor 通过惩罚在同一时间步生成已被其他 beams 选择的 tokens 的 beams 来解决这个问题。

示例

>>> 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 of shape (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.InfNanRemoveLogitsProcessor

< >

( )

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

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

__call__

< >

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

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.LogitNormalization

< >

( )

LogitsProcessor,用于使用 log-softmax 归一化分数。在应用 logits processors 或 warpers 之后,在 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.LogitsProcessor

< >

( )

所有可以在生成过程中应用的 logits processors 的抽象基类。

__call__

< >

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

参数

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

返回

torch.FloatTensor,形状为 (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 of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 什么是输入 IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时,这些可以是每个词汇的 logits;当使用 beam search 时,这些可以是每个词汇 token 的 log softmax。
  • kwargs (Dict[str, Any], optional) — 特定于 logits processor 的其他 kwargs。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.MinLengthLogitsProcessor

< >

( min_length: int eos_token_id: typing.Union[int, typing.List[int], torch.Tensor] device: str = 'cpu' )

参数

  • min_length (int) — 最短长度,低于此长度时,eos_token_id 的分数将设置为 -float("Inf")
  • eos_token_id (Union[int, List[int], torch.Tensor]) — end-of-sequence token 的 id。
  • device (str, optional, defaults to "cpu") — 用于分配 tensors 的设备。

LogitsProcessor,通过将 EOS 概率设置为 0 来强制执行最小长度。请注意,对于仅解码器模型(如大多数 LLM),长度包括 prompt。

示例

>>> 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.MinNewTokensLengthLogitsProcessor

< >

( prompt_length_to_skip: int min_new_tokens: int eos_token_id: typing.Union[int, typing.List[int], torch.Tensor] 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 相反,此处理器忽略 prompt。

示例

>>> 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (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) — 不能被过滤的 tokens 的最小数量。

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: typing.List[typing.List[int]] eos_token_id: typing.Union[int, typing.List[int], torch.Tensor, NoneType] = None )

参数

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

LogitsProcessor 强制执行永不选择指定的序列。

为了获得不应出现在生成文本中的单词的 token ids,请确保在初始化 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.NoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

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

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

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

示例

>>> 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,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.PrefixConstrainedLogitsProcessor

< >

( prefix_allowed_tokens_fn: typing.Callable[[int, torch.Tensor], typing.List[int]] num_beams: int )

参数

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

LogitsProcessor,用于强制约束生成,并且对于前缀条件约束生成非常有用。有关更多信息,请参阅 Autoregressive Entity Retrieval

示例

>>> 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,形状为 (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)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

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,形状为 (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)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

transformers.SequenceBiasLogitsProcessor

< >

( sequence_bias: typing.List[typing.List[typing.Union[typing.List[int], float]]] )

参数

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

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

在 token 级别,对单词进行偏差处理与对前面有空格的单词进行偏差处理是不同的。如果你想在句子中间对 “foo” 进行偏差处理,你可能需要添加一个前缀空格并改为对 “ foo” 进行偏差处理。查看我们的 NLP 课程的 tokenizer 部分,以了解原因: https://huggingface.co/learn/nlp-course/chapter2/4#pt

示例

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt")

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

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

>>> # IMPORTANT: Remember our tip about adding spaces before words to bias them correctly.
>>> sequence_bias = [[get_tokens("Trump"), -10.0],]  # will fail to apply bias
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Trump Sr.

>>> sequence_bias = [[get_tokens(" Trump"), -10.0],]  # will work
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Harper. He

>>> # We can also add a positive bias to nudge the model towards specific tokens or continuations. This technique
>>> # is also more effective when paired up with beam search.
>>> sequence_bias = [[get_tokens(" Donald Duck"), 10.0],]
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, num_beams=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald Duck. He is

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) torch.FloatTensor,形状为 (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)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

transformers.SuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index device: str = 'cpu' )

SuppressTokensAtBeginLogitsProcessorgenerate 函数开始使用 begin_index 个 token 生成时,立即抑制 token 列表。这应该确保 begin_suppress_tokens 定义的 token 不会在开头生成。最初为 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,形状为 (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)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

transformers.SuppressTokensLogitsProcessor

< >

( suppress_tokens device: str = 'cpu' )

此 processor 可用于抑制 token 列表。processor 会将其 log 概率设置为 -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,形状为 (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)) — 语言建模头的预测分数。当不使用集束搜索时,这些可以是每个词汇的 logits;当使用集束搜索时,这些可以是每个词汇 token 的 log softmax。

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

transformers.SynthIDTextWatermarkLogitsProcessor

< >

( ngram_len: int keys: typing.List[int] sampling_table_size: int sampling_table_seed: int context_history_size: int device: device skip_first_ngram_calls: bool = False debug_mode: bool = False )

参数

  • ngram_len (int) — Ngram 长度。
  • keys (List[int]) — 水印密钥序列,每个深度一个。
  • sampling_table_size (int) — 采样表的大小。
  • sampling_table_seed (int) — 用于生成采样表的随机种子。
  • context_history_size (int) — 用于跟踪已见上下文的张量大小。
  • device (torch.device) — 要使用的设备。
  • skip_first_ngram_calls (bool, optional, defaults to False) — 是否跳过首个 ngram 调用。
  • debug_mode (bool, optional, optional, defaults to False) — 在应用水印修改之前,logits 被修改为均匀分布。这是为了测试实现。

Logits 处理器,用于实现文本生成模型的水印技术。此类有助于应用 SynthID 文本水印,这是一种将不可察觉的信号嵌入到生成的文本中,以帮助检测合成内容的方法。它通过微妙地操纵文本生成期间的 token 选择概率来运作,这种方式可以在以后可靠地恢复以进行验证。

主要特点

  • 状态管理: 维护内部状态以跟踪 token 序列并动态生成水印密钥。

  • 密钥生成: 基于 token 序列和水印参数计算哈希值,为每个位置创建唯一的密钥。

  • G 值采样: 采用预先计算的采样表,根据生成的密钥对水印值(g 值)进行采样。

  • 分数调整: 应用计算出的 g 值来修改生成期间的 token 概率,从而嵌入水印。

  • 上下文重复处理: 结合逻辑以避免在重复上下文中对 token 进行水印处理,从而保持自然性。

  • EOS Token 掩码: 支持掩蔽句子结束 token,以防止其包含在水印计算中。

  • 实用函数: 提供直接计算 g 值、检查上下文重复、创建 EOS token 掩码以及估计预期平均 g 值的函数。

有关此内容的更多详细信息,请参阅论文链接:https://www.nature.com/articles/s41586-024-08025-4

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

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

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)

__call__

< >

( input_ids: LongTensor scores: FloatTensor ) 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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.TemperatureLogitsWarper

< >

( temperature: float )

参数

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

LogitsProcessor 用于温度(指数缩放输出概率分布),这实际上意味着它可以控制预测 token 的随机性。通常与 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,形状为 (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,形状为 (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 过滤保留的最高概率词汇 token 的数量。
  • filter_value (float, optional, defaults to -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能被过滤的 token 的最小数量。

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,形状为 (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,形状为 (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 或更高的最小概率 token 集合用于生成。
  • filter_value (float, optional, defaults to -inf) — 所有过滤后的值都将设置为此浮点值。
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能被过滤的 token 的最小数量。

LogitsProcessor,用于执行 top-p,即限制为概率总和小于等于 prob_cut_off 的 top token。通常与 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,形状为 (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,形状为 (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.9。
  • filter_value (float, 可选, 默认为 -inf) — 所有被过滤的值将被设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的 tokens 的最小数量。

LogitsProcessor,执行典型的解码。受到人类如何使用语言的启发,它优先考虑那些对数概率接近 token 概率分布熵的 tokens。这意味着最有可能的 tokens 可能会在此过程中被丢弃。

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

示例

>>> 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,形状为 (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,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

class transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor

< >

( guidance_scale: float model unconditional_ids: typing.Optional[torch.LongTensor] = None unconditional_attention_mask: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = True )

参数

  • guidance_scale (float) — 用于无分类器引导 (CFG) 的引导缩放。通过设置 guidance_scale != 1 启用 CFG。较高的引导缩放鼓励模型生成与输入提示更紧密相关的样本,但通常以质量较差为代价。小于 1 的值具有相反的效果,同时使通过 negative_prompt_ids(如果有)提供的负面提示充当正面提示。
  • model (PreTrainedModel) — 计算无条件分数的模型。据推测与计算条件分数的模型相同。两个模型必须使用相同的 tokenizer。
  • unconditional_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于无条件分支的词汇表中输入序列 tokens 的索引。如果未设置,则默认为提示的最后一个 token。
  • unconditional_attention_mask (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 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: typing.Optional[int] = None _detect_timestamp_from_logprob: typing.Optional[bool] = 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, 可选) — 是否可以从所有时间戳的 logprobs 中预测时间戳。

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

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

示例

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

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

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 ) torch.FloatTensor,形状为 (batch_size, config.vocab_size)

参数

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

返回

torch.FloatTensor,形状为 (batch_size, config.vocab_size)

处理后的预测分数。

TensorFlow

class transformers.TFForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

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

__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 时,强制作为最后一个生成的令牌的 ID。

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

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFForceTokensLogitsProcessor

< >

( force_token_map: typing.List[typing.List[int]] )

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

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFLogitsProcessor

< >

( )

所有可以在生成过程中应用的 logits processors 的抽象基类。

__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()

    什么是输入 ID?

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

返回

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

处理后的预测分数。

用于处理 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 (tf.Tensor 类型,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

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

返回

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

处理后的预测分数。

class transformers.TFLogitsWarper

< >

( )

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

__call__

< >

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

参数

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

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

    什么是输入 IDs?

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

返回

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

处理后的预测分数。

用于 warping logits 的 TF 方法。

class transformers.TFMinLengthLogitsProcessor

< >

( min_length: int eos_token_id: int )

参数

  • min_length (int 类型) — 最短长度,低于此长度时,eos_token_id 的分数将被设置为 -float("Inf")
  • eos_token_id (int 类型) — 序列结束 token 的 id。

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

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFNoBadWordsLogitsProcessor

< >

( bad_words_ids: typing.List[typing.List[int]] eos_token_id: int )

参数

  • bad_words_ids (List[List[int]] 类型) — 不允许生成的 token ids 列表。为了获得不应在生成的文本中出现的单词的 tokens,请确保在初始化 tokenizer 时设置 add_prefix_space=True,并使用 tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space 参数仅适用于某些慢速 tokenizers,因为快速 tokenizers 的前缀行为来自 pre tokenizers。 阅读更多 此处
  • eos_token_id (int 类型) — 序列结束 token 的 id。

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

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFNoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

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

TFLogitsProcessor,它强制执行 n-grams 不重复。 请参阅 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 )

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

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

class transformers.TFSuppressTokensLogitsProcessor

< >

( suppress_tokens )

此处理器可以用于抑制 token 列表。处理器会将其 log probs 设置为 -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 过滤的保留的最高概率词汇 tokens 的数量。
  • filter_value (float, 可选, 默认为 -inf) — 所有被过滤的值都将被设置为这个浮点数值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的最小 token 数量。

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 或更高的最小概率 tokens 集合,用于生成。
  • filter_value (float, 可选, 默认为 -inf) — 所有被过滤的值都将被设置为这个浮点数值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的最小 token 数量。

TFLogitsWarper 执行 top-p,即限制为总和 <= prob_cut_off 的 top tokens。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

FLAX

class transformers.FlaxForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

FlaxLogitsProcessor 强制将指定的 token 作为第一个生成的 token。

__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 时,强制作为最后一个生成的 token 的 id。

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

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxForceTokensLogitsProcessor

< >

( force_token_map )

参数

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

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

__call__

< >

( input_ids: Array scores: Array cur_len: int )

class transformers.FlaxLogitsProcessor

< >

( )

所有可以在生成过程中应用的 logits processors 的抽象基类。

__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() 以了解详情。

    什么是输入 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() 以了解详情。

    什么是输入 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

< >

( )

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

__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() 以了解详情。

    什么是输入 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 生成时,抑制 tokens 列表。 这应确保由 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, 可选, 默认为 -inf) — 所有被过滤的值都将被设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 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, 可选, 默认为 -inf) — 所有被过滤的值都将被设置为此浮点值。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的 tokens 的最小数量。

FlaxLogitsWarper 执行 top-p,即限制为概率总和 <= 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, 可选, 默认为 50257): end-of-sequence token 的 id。 no_timestamps_token_id (int, 可选, 默认为 50363): "<|notimestamps|>" token 的 id。 max_initial_timestamp_index (int, 可选, 默认为 1): 用于设置初始时间戳的最大值。这用于防止模型预测时间戳过于超前未来。

Whisper 特定处理器。此处理器可用于强制列表 tokens。处理器会将其 log probs 设置为 inf,以便在其对应的索引处进行采样。

__call__

< >

( input_ids scores cur_len )

StoppingCriteria

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

class transformers.StoppingCriteria

< >

( )

可应用于生成过程中的所有停止标准的抽象基类。

如果您的停止标准取决于 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], 可选) — 其他特定于停止标准的 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], 可选) — 其他特定于停止条件的 kwargs。

class transformers.MaxLengthCriteria

< >

( max_length: int max_position_embeddings: typing.Optional[int] = None )

参数

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

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

__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], 可选) — 其他特定于停止条件的 kwargs。

class transformers.MaxTimeCriteria

< >

( max_time: float initial_timestamp: typing.Optional[float] = None )

参数

  • max_time (float) — 生成允许的最大时间(秒)。
  • initial_time (float, 可选, 默认为 time.time()) — 允许生成时间的开始时间。

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

__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], 可选) — 其他特定于停止条件的 kwargs。

class transformers.StopStringCriteria

< >

( tokenizer: PreTrainedTokenizerBase stop_strings: typing.Union[str, typing.List[str]] )

参数

  • 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”。这与停止字符串匹配,因此整个字符串都匹配了。

但是,我们如何使用张量运算来计算这些匹配呢?很简单:我们高效地预计算所有 token 所需的信息!对于每个 token,我们计算

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

例如,对于 token “pped”,我们将计算出 1 个字符的结尾重叠,没有内部匹配位置,以及长度为 4。对于 token “to”,我们将计算出没有结尾重叠,一个内部匹配位置 1(从结尾开始计数),以及长度为 2。对于 token “s”,我们将计算出没有结尾重叠,一个内部匹配位置 3(同样从结尾开始计数),以及长度为 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() 了解详细信息。

    什么是 input 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: typing.Union[int, typing.List[int], torch.Tensor] )

参数

  • 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() 了解详细信息。

    什么是 input 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。

约束

可以使用 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)

参数

  • stateful(bool) — 是否不仅为新实例复制约束,还复制其状态。

返回

constraint(Constraint)

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

创建此约束的新实例。

does_advance

< >

( token_id: int )

读取一个 token 并返回它是否产生进展。

remaining

< >

( )

返回为了完成此约束,advance() 还需要执行的剩余步骤数。

reset

< >

( )

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

test

< >

( )

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

update

< >

( token_id: int ) stepped(bool)

参数

  • token_id(int) — beam search 中新生成的 token 的 ID。

返回

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: typing.List[int] )

参数

  • token_ids (List[int]) — 输出中必须生成的词元 ID。

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

class transformers.DisjunctiveConstraint

< >

( nested_token_ids: typing.List[typing.List[int]] )

参数

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

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

class transformers.ConstraintListState

< >

( constraints: typing.List[transformers.generation.beam_constraints.Constraint] )

参数

  • constraints (List[Constraint]) — 必须由集束评分器满足的 Constraint 对象列表。

用于集束评分器跟踪其在约束列表中的进度的类。

advance

< >

( )

要生成的词元列表,以便我们可以取得进展。 “列表”不是指将完全满足约束的词元列表。

给定约束 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: typing.Optional[typing.List[int]] )

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

集束搜索

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 (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 对应于哪个束假设。
  • pad_token_id (int, 可选) — 填充词元的 ID。
  • eos_token_id (Union[int, List[int]], 可选) — 序列结束词元的 ID。 可选地,使用列表来设置多个序列结束词元。
  • beam_indices (torch.LongTensor, 可选) — 束索引,指示每个词元对应于哪个束假设。
  • group_index (int, 可选) — 束组的索引。与 ~PreTrainedModel.group_beam_search 一起使用。

返回

UserDict

由上述字段组成的字典

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

finalize

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor max_length: int **kwargs ) torch.LongTensor,形状为 (batch_size * num_return_sequences, sequence_length)

参数

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

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

    什么是输入 ID?

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

返回

torch.LongTensor,形状为 (batch_size * num_return_sequences, sequence_length)

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

class transformers.BeamSearchScorer

< >

( batch_size: int num_beams: int device: device length_penalty: typing.Optional[float] = 1.0 do_early_stopping: typing.Union[bool, str, NoneType] = False num_beam_hyps_to_keep: typing.Optional[int] = 1 num_beam_groups: typing.Optional[int] = 1 max_length: typing.Optional[int] = None )

参数

  • batch_size (int) — input_ids 的批次大小,标准束搜索解码将并行运行于这些 input_ids 上。
  • num_beams (int) — 束搜索的束数量。
  • device (torch.device) — 定义设备类型(例如"cpu""cuda"),BeamSearchScorer 的此实例将分配到该设备上。
  • 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, 可选) — 要生成的序列的最大长度。

BeamScorer,实现标准束搜索解码。

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

有关多样化束搜索算法和实现的参考资料:Ashwin Kalyan 的 DBS 实现

process

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor pad_token_id: typing.Union[int, torch.Tensor, NoneType] = None eos_token_id: typing.Union[int, typing.List[int], torch.Tensor, NoneType] = None beam_indices: typing.Optional[torch.LongTensor] = None group_index: typing.Optional[int] = 0 decoder_prompt_len: typing.Optional[int] = 0 )

finalize

< >

( input_ids: LongTensor final_beam_scores: FloatTensor final_beam_tokens: LongTensor final_beam_indices: LongTensor max_length: int pad_token_id: typing.Union[int, torch.Tensor, NoneType] = None eos_token_id: typing.Union[int, typing.List[int], torch.Tensor, NoneType] = None beam_indices: typing.Optional[torch.LongTensor] = None decoder_prompt_len: typing.Optional[int] = 0 )

class transformers.ConstrainedBeamSearchScorer

< >

( batch_size: int num_beams: int constraints: typing.List[transformers.generation.beam_constraints.Constraint] device: device length_penalty: typing.Optional[float] = 1.0 do_early_stopping: typing.Union[bool, str, NoneType] = False num_beam_hyps_to_keep: typing.Optional[int] = 1 num_beam_groups: typing.Optional[int] = 1 max_length: typing.Optional[int] = None )

参数

  • batch_size (int) — input_ids 的批次大小,标准束搜索解码将并行运行于这些 input_ids 上。
  • num_beams (int) — 束搜索的束数量。
  • constraints (List[Constraint]) — 正向约束列表,表示为 Constraint 对象,这些约束必须在生成输出中满足。 有关更多信息,应阅读 Constraint 的文档。
  • device (torch.device) — 定义设备类型(例如"cpu""cuda"),BeamSearchScorer 的此实例将分配到该设备上。
  • 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, 可选) — 要生成的序列的最大长度。

BeamScorer,实现了约束束搜索解码。

process

< >

( input_ids: LongTensor next_scores: FloatTensor next_tokens: LongTensor next_indices: LongTensor scores_for_all_vocab: FloatTensor pad_token_id: typing.Union[int, torch.Tensor, NoneType] = None eos_token_id: typing.Union[int, typing.List[int], torch.Tensor, NoneType] = None beam_indices: typing.Optional[torch.LongTensor] = None decoder_prompt_len: typing.Optional[int] = 0 ) 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 对应于哪个束假设。
  • scores_for_all_vocab (形状为 (batch_size * num_beams, sequence_length)torch.FloatTensor) — 词汇表中所有 tokens 对于每个束假设的得分。
  • pad_token_id (int, 可选) — padding token 的 id。
  • eos_token_id (Union[int, List[int]], 可选) — end-of-sequence token 的 id。 可选地,使用列表来设置多个 end-of-sequence tokens。
  • beam_indices (torch.LongTensor, 可选) — 束索引,指示每个 token 对应于哪个束假设。
  • decoder_prompt_len (int, 可选) — 解码器输入中包含的 prompt 的长度。

返回

UserDict

由上述字段组成的字典

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

  • next_beam_tokens (torch.FloatTensor,形状为 (batch_size * num_beams)) — 要添加到未完成的束假设的下一个词元。

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

finalize

< >

( input_ids: LongTensor final_beam_scores: FloatTensor final_beam_tokens: LongTensor final_beam_indices: LongTensor max_length: int pad_token_id: typing.Union[int, torch.Tensor, NoneType] = None eos_token_id: typing.Union[int, typing.List[int], torch.Tensor, NoneType] = None beam_indices: typing.Optional[torch.LongTensor] = None decoder_prompt_len: typing.Optional[int] = 0 )

Streamers

class transformers.TextStreamer

< >

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

参数

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

简单的文本 streamer,在形成完整单词后立即将 token(s) 打印到 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 )

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

class transformers.TextIteratorStreamer

< >

( tokenizer: 'AutoTokenizer' skip_prompt: bool = False timeout: Optional[float] = None **decode_kwargs )

参数

  • tokenizer (AutoTokenizer) — 用于解码 tokens 的 tokenizer。
  • skip_prompt (bool, 可选, 默认为 False) — 是否跳过 .generate() 的 prompt。 例如,对于聊天机器人很有用。
  • timeout (float, 可选) — 文本队列的超时时间。 如果为 None,队列将无限期阻塞。 当 .generate() 在单独的线程中调用时,这对于处理异常很有用。
  • decode_kwargs (dict, 可选) — 传递给 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 )

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

class transformers.AsyncTextIteratorStreamer

< >

( tokenizer: 'AutoTokenizer' skip_prompt: bool = False timeout: Optional[float] = None **decode_kwargs )

参数

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

Raises

TimeoutError

  • TimeoutError — 如果 token 生成时间超过超时值。

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

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

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, AsyncTextIteratorStreamer
>>> from threading import Thread
>>> import asyncio

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

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> async def main():
...     # Important: AsyncTextIteratorStreamer must be initialized inside a coroutine!
...     streamer = AsyncTextIteratorStreamer(tok)
...     generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
...     thread = Thread(target=model.generate, kwargs=generation_kwargs)
...     thread.start()
...     generated_text = ""
...     async for new_text in streamer:
...         generated_text += new_text
>>>     print(generated_text)
>>> asyncio.run(main())
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,

on_finalized_text

< >

( text: str stream_end: bool = False )

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

缓存

class transformers.Cache

< >

( )

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

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None )

参数

  • key_states (torch.Tensor) — 要缓存的新 key states。
  • value_states (torch.Tensor) — 要缓存的新 value states。
  • 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: typing.Optional[int] = 4 axis_key: typing.Optional[int] = 0 axis_value: typing.Optional[int] = 0 q_group_size: typing.Optional[int] = 64 residual_length: typing.Optional[int] = 128 compute_dtype: typing.Optional[torch.dtype] = torch.float16 device: typing.Optional[str] = 'cpu' )

参数

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

量化缓存设置的配置类。

validate

< >

( )

验证传递的参数是否正确

class transformers.DynamicCache

< >

( _distributed_cache_data: typing.Iterable = None )

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

它将 Key 和 Value 状态存储为 tensors 列表,每层一个。每个 tensor 的预期形状为 [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: typing.Optional[typing.Dict[str, typing.Any]] = 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: typing.Optional[int] = 0 )

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

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的束索引,重新排序用于束搜索的缓存。

to_legacy_cache

< >

( )

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

from_legacy_cache

< >

( past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )

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

class transformers.QuantizedCache

< >

( cache_config: QuantizedCacheConfig )

一种量化器缓存,类似于 KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache paper 中描述的缓存。它允许模型生成更长的序列长度,而无需通过应用量化为键值缓存分配过多内存。

缓存有两种类型的存储,一种用于原始精度,另一种用于量化缓存。 residual length 被设置为原始精度缓存的最大容量。当长度超过最大容量时,原始精度缓存将被丢弃并移入量化缓存。与论文中描述的相反,量化是按通道完成的,并为键和值设置了 q_group_size

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

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None )

get_seq_length

< >

( layer_idx: typing.Optional[int] = 0 )

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

class transformers.QuantoQuantizedCache

< >

( cache_config: CacheConfig )

参数

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

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

示例

>>> # 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 作为后端执行量化。当前实现支持 int2int4int8 dtypes。

示例

>>> # 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 tokens 的数量。 有关更多信息,请参阅原始论文。

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

它将 Key 和 Value 状态存储为 tensors 列表,每层一个。每个 tensor 的预期形状为 [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: typing.Optional[typing.Dict[str, typing.Any]] = None )

参数

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

使用层 layer_idx 的新 key_statesvalue_states 更新缓存。

get_seq_length

< >

( layer_idx: typing.Optional[int] = 0 )

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

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的束索引,重新排序用于束搜索的缓存。

class transformers.OffloadedCache

< >

( )

DynamicCache 的直接替代品,它以消耗更多 CPU 内存为代价来节省加速器(GPU、XPU)内存。 对于从具有超长上下文的模型生成内容非常有用。

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

update

< >

( key_states: Tensor value_states: Tensor layer_idx: int cache_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = 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: typing.Optional[int] = None layer_device_map: typing.Optional[typing.Dict[int, typing.Union[str, torch.device, int]]] = None )

参数

  • config (PretrainedConfig) — 配置文件,用于定义初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批次大小。 请注意,如果使用较小的批次大小,则必须实例化一个新实例。 如果您手动设置批次大小,请确保考虑波束搜索时波束的数量
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (torch.devicestr) — 缓存应初始化的设备。 如果您使用超过 1 个计算设备,则应传递 layer_device_map 参数。
  • dtype (torch.dtype, optional, defaults to torch.float32) — 初始化层时使用的默认 dtype
  • layer_device_map(`Dict[int, Union[str, torch.device, int]]], optional) -- 层与其设备之间的映射。当您手动初始化缓存并且模型在不同的 gpu 之间拆分时,这是必需的。您可以通过检查关联的 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: typing.Optional[typing.Dict[str, typing.Any]] = None )

参数

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

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

get_seq_length

< >

( layer_idx: typing.Optional[int] = 0 )

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

reset

< >

( )

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

class transformers.OffloadedStaticCache

< >

( config: PretrainedConfig max_batch_size: int max_cache_len: typing.Optional[int] device: typing.Union[str, torch.device] dtype: typing.Optional[torch.dtype] = None offload_device: typing.Union[str, torch.device] = device(type='cpu') layer_device_map: typing.Optional[typing.Dict[int, typing.Union[str, torch.device, int]]] = None )

参数

  • config (PretrainedConfig) — 配置文件,用于定义初始化静态缓存所需的形状相关属性。
  • max_batch_size (int) — 模型将使用的最大批次大小。
  • max_cache_len (int) — 模型将使用的最大序列长度。
  • device (Union[str, torch.device]) — 缓存应初始化的设备。 如果您使用超过 1 个计算设备,则应传递 layer_device_map 参数。
  • dtype (torch.dtype, optional) — 初始化缓存时使用的默认 dtype
  • offload_device (Union[str, torch.device], optional, defaults to cpu) — 要卸载到的设备。 默认为 CPU。
  • layer_device_map (Dict[int, Union[str, torch.device, int]], optional) — 层与其设备之间的映射。当您手动初始化缓存并且模型在不同的 gpu 之间拆分时,这是必需的。您可以通过检查关联的 device_map 来了解哪些层映射到哪个设备: model.hf_device_map

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: typing.Optional[typing.Dict[str, typing.Any]] = None )

参数

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

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

get_seq_length

< >

( layer_idx: typing.Optional[int] = 0 )

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

reset

< >

( )

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

class transformers.HybridCache

< >

( config: PretrainedConfig batch_size: int = None max_cache_len: int = None device: typing.Union[torch.device, str] = None dtype: dtype = torch.float32 max_batch_size: typing.Optional[int] = None layer_device_map: typing.Optional[typing.Dict[int, typing.Union[str, torch.device, int]]] = None )

参数

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

Hybrid Cache 类与 torch.compile 一起用于 Gemma2 模型,这些模型在每隔一层中交替使用局部滑动窗口注意力机制和全局注意力机制。 在底层,Hybrid Cache 利用 [“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: typing.Optional[typing.Dict[str, typing.Any]] = None )

get_seq_length

< >

( layer_idx: typing.Optional[int] = 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: typing.Optional[int] = None layer_device_map: typing.Optional[typing.Dict[int, typing.Union[str, torch.device, int]]] = None )

参数

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

滑动窗口缓存类,与 torch.compile 一起用于像 Mistral 这样支持滑动窗口注意力的模型。 每次当我们尝试更新缓存时,我们都会基于 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: typing.Optional[typing.Dict[str, typing.Any]] = 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: typing.Optional[int] = 0 )

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

to_legacy_cache

< >

( )

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

from_legacy_cache

< >

( past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )

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

reset

< >

( )

reorder_cache

< >

( beam_idx: LongTensor )

根据所选的束索引,重新排序用于束搜索的缓存。

class transformers.MambaCache

< >

( config: PretrainedConfig batch_size: int = None dtype: dtype = torch.float16 device: typing.Union[torch.device, str, NoneType] = None max_batch_size: typing.Optional[int] = None )

参数

  • config (`PretrainedConfig`) — 配置文件,定义了初始化静态缓存所需的形状相关属性。
  • batch_size (int) — 模型将使用的批次大小。请注意,如果使用较小的批次大小,则必须实例化新的实例。
  • dtype (torch.dtype, 可选, 默认为 torch.float16) — 初始化层时使用的默认 dtype
  • device (torch.devicestr, 可选) — 缓存应在其上初始化的设备。应与层相同。

用于 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.WatermarkingConfig

< >

( greenlist_ratio: typing.Optional[float] = 0.25 bias: typing.Optional[float] = 2.0 hashing_key: typing.Optional[int] = 15485863 seeding_scheme: typing.Optional[str] = 'lefthash' context_width: typing.Optional[int] = 1 )

此类包含水印生成的参数,应在 generate 期间传递到 GenerationConfig 中。有关参数的更多详细信息,请参阅本文

接受以下键

  • greenlist_ratio (float): 用于水印。用于词汇表大小的“绿色”标记的比率。默认为 0.25。
  • bias (float): 与水印一起使用。添加到选定的“绿色”标记 logits 的偏差。默认为 2.0。
  • hashing_key (int): 用于水印的哈希键。默认为 15485863(第一百万个素数)。
  • seeding_scheme (str): 用于水印的算法。接受以下值
    • “lefthash”(默认):“绿色”标记选择取决于上一个标记(论文中的算法 2)
    • “selfhash”:“绿色”标记选择取决于当前标记本身(论文中的算法 3)。此方案的缺点是它考虑了所有可能的下一个标记,并且可能比“lefthash”慢。
  • context_width(int): 用于播种的先前标记的上下文长度。较高的上下文长度使水印更加鲁棒。

__call__

( *args **kwargs )

将自身作为函数调用。

class transformers.WatermarkDetector

< >

( model_config: PretrainedConfig device: str watermarking_config: typing.Union[transformers.generation.configuration_utils.WatermarkingConfig, typing.Dict] ignore_repeated_ngrams: bool = False max_cache_size: int = 128 )

参数

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

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

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

示例

>>> 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 ) WatermarkDetectorOutputnp.array

参数

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

返回

WatermarkDetectorOutputnp.array

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

ma

class transformers.BayesianDetectorConfig

< >

( watermarking_depth: int = None base_rate: float = 0.5 **kwargs )

参数

  • watermarking_depth (int, 可选) — 锦标赛层数。
  • base_rate (float1, 可选, 默认为 0.5) — 文本被添加水印的先验概率 P(w)。

这是配置类,用于存储 BayesianDetectorModel 的配置。它用于根据指定的参数实例化贝叶斯检测器模型。

配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请阅读 PretrainedConfig 中的文档。

class transformers.BayesianDetectorModel

< >

( config )

参数

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

用于水印检测的贝叶斯分类器。

此检测器使用贝叶斯规则来计算水印分数,即后验概率 P(watermarked|g_values) 和 P(unwatermarked|g_values) 比率的对数的 sigmoid 函数。有关更多详细信息,请参阅论文中关于 BayesianScore 的部分。论文 URL:https://www.nature.com/articles/s41586-024-08025-4

请注意,此检测器仅适用于使用 Bernoulli(0.5) g 值分布的非失真锦标赛水印。

此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( g_values: Tensor mask: Tensor labels: typing.Optional[torch.Tensor] = None loss_batch_weight = 1 return_dict = False )

参数

  • g_values (torch.Tensor,形状为 (batch_size, seq_len, watermarking_depth, ...)) — g 值(值为 0 或 1)
  • mask — 形状为 [batch_size, seq_len] 的二进制数组,指示应使用哪些 g 值。掩码值为 0 的 g 值将被丢弃。

计算添加水印的后验概率 P(watermarked|g_values)。

class transformers.SynthIDTextWatermarkingConfig

< >

( ngram_len: int keys: typing.List[int] context_history_size: int = 1024 sampling_table_seed: int = 0 sampling_table_size: int = 65536 skip_first_ngram_calls: bool = False debug_mode: bool = False )

参数

  • ngram_len (int) — N 元语法长度。
  • keys (List[int]) — 一系列水印密钥,每个深度一个。
  • context_history_size (int, 可选, 默认为 1024) — 用于跟踪已见上下文的张量大小。
  • sampling_table_seed (int, 可选, 默认为 0) — 用于生成采样表的随机种子。
  • sampling_table_size (int, 可选, 默认为 65536) — 采样表的大小。
  • skip_first_ngram_calls (bool, 可选, 默认为 False) — 是否跳过第一个 ngram 调用。
  • debug_mode (bool, optional, 可选, 默认为 False) — 修改 logits 为均匀分布,然后应用水印修改。这是为了测试实现。

此类包含水印生成的参数,应在 generate 期间传递到 GenerationConfig 中。有关参数的更多详细信息,请参阅 这篇论文

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

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

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)

class transformers.SynthIDTextWatermarkDetector

< >

( detector_module: BayesianDetectorModel logits_processor: SynthIDTextWatermarkLogitsProcessor tokenizer: typing.Any )

参数

SynthID 文本水印检测器类。

此类必须使用经过训练的贝叶斯检测器模块进行初始化,请查看 examples/synthid_text/detector_training.py 中的脚本,例如在训练/保存/加载此检测器模块时。该文件夹还展示了此检测器的示例用例。

示例

>>> from transformers import (
...     AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector
... )

>>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector.
>>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector")
>>> logits_processor = SynthIDTextWatermarkLogitsProcessor(
...     **detector_model.config.watermarking_config, device="cpu"
... )
>>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name)
>>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer)

>>> # Test whether a certain string is watermarked
>>> test_input = tokenizer(["This is a test input"], return_tensors="pt")
>>> is_watermarked = detector(test_input.input_ids)

__call__

< >

( tokenized_outputs: Tensor )

编译工具

class transformers.CompileConfig

< >

( fullgraph: bool = True dynamic: typing.Optional[bool] = None backend: typing.Union[str, typing.Callable] = 'inductor' mode: str = 'reduce-overhead' options: typing.Optional[dict] = None )

参数

  • fullgraph (bool, 可选, 默认为 True) — 如果为 True,则要求整个前向过程都可以在单个图中捕获。
  • dynamic (boolNone, 可选) — 是否尝试使用动态形状图。
  • backend (strCallable, 可选, 默认为 "inductor") — 要使用的后端。
  • mode (str, 可选, 默认为 "reduce-overhead") — 控制性能和开销之间的平衡。
  • options (dict, 可选) — 传递给后端的选项字典。

此类在使用 generate 中的自动编译时,保存与 torch.compile 行为相关的参数。 有关参数的更多详细信息,请参阅 torch.compile

示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer, CompileConfig

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

>>> # Automatic compile configuration, used with static cache
>>> compile_config = CompileConfig(dynamic=True)

>>> # Generation with static cache and compile config
>>> input = tokenizer.encode("Hello there, how", return_tensors="pt").cuda()
>>> output = model.generate(
...     input, do_sample=False, max_new_tokens=300, cache_implementation="static", compile_config=compile_config
... )
>>> output_text = tokenizer.batch_decode(output, skip_special_tokens=True)[0]

__call__

( *args **kwargs )

将自身作为函数调用。

< > 在 GitHub 上更新