Transformers 文档

生成工具

生成工具

本页面列出了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: 生成的标记序列
  • 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

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 (torch.LongTensor of shape (batch_size, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于max_length,要么由于eos_token_id而提前结束的所有批次较短。
  • scores (tuple(torch.FloatTensor) 可选, 当 output_scores=True 时返回) — 语言建模头处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 torch.FloatTensor 元组, 每个张量的形状为 (batch_size, config.vocab_size).
  • logits (tuple(torch.FloatTensor) 可选, 当 output_logits=True 时返回) — 语言建模头部的未处理预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素组成的 torch.FloatTensor 元组(每个生成的标记一个元素), 每个张量的形状为 (batch_size, config.vocab_size).
  • 注意力 (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(torch.FloatTensor)), 可选, 当 output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, generated_length, hidden_size).
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选, 当 use_cache=True 时返回) — 返回模型缓存,用于加速解码。不同的模型有不同的缓存格式,请查看模型的文档。通常是一个 Cache 实例。

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

transformers.generation.GenerateEncoderDecoderOutput

< >

( sequences: LongTensor = None scores: 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 )

参数

  • 序列 (torch.LongTensor 形状为 (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于 max_length,要么由于 eos_token_id 所有批次提前结束而较短。
  • scores (tuple(torch.FloatTensor) 可选, 当 output_scores=True 时返回) — 语言建模头处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 torch.FloatTensor 元组, 每个张量的形状为 (batch_size, config.vocab_size).
  • logits (tuple(torch.FloatTensor) 可选, 当 output_logits=True 时返回) — 语言建模头部的未处理预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 torch.FloatTensor 元组, 每个张量的形状为 (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, 当 output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • cross_attentions (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • decoder_hidden_states (tuple(tuple(torch.FloatTensor)), 可选, 当 output_hidden_states=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, generated_length, hidden_size).
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选, 当传递 use_cache=Trueconfig.use_cache=True 时返回) — 返回模型缓存,用于加速解码。不同的模型有不同的缓存格式,请查看模型的文档。通常是一个 Cache 实例。

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

transformers.generation.GenerateBeamDecoderOnlyOutput

< >

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

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

transformers.generation.GenerateBeamEncoderDecoderOutput

< >

( sequences: LongTensor = None sequences_scores: 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 )

参数

  • 序列 (torch.LongTensor 形状为 (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, 当 output_scores=True 时返回) — 生成的 sequences 的最终束分数.
  • scores (tuple(torch.FloatTensor) 可选, 当 output_scores=True 时返回) — 每个生成步骤中每个词汇标记的束转换分数。束转换分数由基于此束中先前生成的标记的对数softmax的标记的对数概率组成。 torch.FloatTensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素), 每个张量的形状为 (batch_size*num_beams, config.vocab_size).
  • logits (tuple(torch.FloatTensor) 可选, 当 output_logits=True 时返回) — 语言建模头部的未处理预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 torch.FloatTensor 元组, 每个张量的形状为 (batch_size, config.vocab_size).
  • beam_indices (torch.LongTensor, 可选, 当 output_scores=True 时返回) — 在每个生成步骤中生成的令牌ID的波束索引。形状为 (batch_size*num_return_sequences, sequence_length)torch.LongTensor.
  • encoder_attentions (tuple(torch.FloatTensor), 可选, 当 output_attentions=True 时返回) — torch.FloatTensor 的元组(解码器的每一层都有一个)形状为 (batch_size, num_heads, sequence_length, sequence_length).
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当 output_hidden_states=True 时返回) — torch.FloatTensor 的元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size*num_beams*num_return_sequences, sequence_length, hidden_size).
  • decoder_attentions (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length).
  • cross_attentions (tuple(tuple(torch.FloatTensor)), 可选, 当 output_attentions=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • decoder_hidden_states (tuple(tuple(torch.FloatTensor)), 可选, 当 output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 torch.FloatTensor,形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size).
  • past_key_values (tuple(tuple(torch.FloatTensor))), 可选, 当 use_cache=True 时返回) — 返回模型的缓存,用于加速解码。不同的模型有不同的缓存格式,请查看模型的文档。通常是一个 Cache 实例。

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

TensorFlow

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 )

参数

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

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

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 )

参数

  • 序列 (tf.Tensor 形状为 (batch_size, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于 max_length,要么由于 eos_token_id 而提前结束的所有批次较短。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言建模头处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组,每个张量的形状为 (batch_size, config.vocab_size).
  • 注意力 (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, generated_length, hidden_size).

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

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 of shape (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于max_length,要么由于eos_token_id而提前结束的所有批次较短。
  • scores (tuple(tf.Tensor) optional, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言建模头处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组, 每个张量的形状为 (batch_size*num_return_sequences, config.vocab_size).
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 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), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size*num_return_sequences, sequence_length, hidden_size).
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_return_sequences, num_heads, generated_length, sequence_length).
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_return_sequences, generated_length, hidden_size).

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

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 )

参数

  • sequences (tf.Tensor 形状为 (batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于 max_length,要么由于 eos_token_id 所有批次提前结束而较短。
  • scores (tuple(tf.Tensor) optional, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言建模头部的处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组,每个张量的形状为 (batch_size*num_return_sequences, config.vocab_size).
  • 注意力 (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (num_return_sequences*batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (num_return_sequences*batch_size, generated_length, hidden_size).

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

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 )

参数

  • 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_sequences), optional, returned when output_scores=True is passed or when config.output_scores=True) — 生成的sequences的最终beam分数。
  • scores (tuple(tf.Tensor) 可选, 当传递output_scores=Trueconfig.output_scores=True时返回) — 在每个生成步骤中为每个词汇表标记处理的束搜索分数。束搜索分数包括每个词汇表标记的对数softmax分数以及此束中先前生成的标记的对数softmax的总和。Tuple of tf.Tensor最多包含max_new_tokens个元素(每个生成的标记一个元素),每个张量的形状为(batch_size*num_beams, config.vocab_size)`.
  • beam_indices (tf.Tensor, optional, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 在每个生成步骤中生成的令牌ID的波束索引。形状为 (batch_size*num_return_sequences, sequence_length)tf.Tensor.
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length).
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 的元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size*num_beams*num_return_sequences, sequence_length, hidden_size).
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length).
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size).

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

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 )

参数

  • 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_sequences), optional, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 生成的 sequences 的最终束分数.
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 在每个生成步骤中,每个词汇表标记的处理后的束搜索分数。束搜索分数包括每个词汇表标记的对数softmax分数以及此束中先前生成的标记的对数softmax的总和。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组,每个张量的形状为 (batch_size*num_beams*num_return_sequences, config.vocab_size).
  • beam_indices (tf.Tensor, 可选, 当传递output_scores=Trueconfig.output_scores=True时返回) — 在每个生成步骤中生成的令牌ID的波束索引。形状为(batch_size*num_return_sequences, sequence_length)tf.Tensor.
  • 注意力 (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams*num_return_sequences, generated_length, hidden_size).

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

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 )

参数

  • 序列 (tf.Tensor 形状为 (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) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 在每个生成步骤中,每个词汇标记的处理后的束搜索分数。束搜索分数包括每个词汇标记的对数softmax分数以及在此束中先前生成的标记的对数softmax的总和。tf.Tensor 的元组,最多包含 max_new_tokens 个元素(每个生成的标记一个元素),每个张量的形状为 (batch_size*num_beams, config.vocab_size).
  • beam_indices (tf.Tensor, 可选, 当传递output_scores=Trueconfig.output_scores=True时返回) — 在每个生成步骤中生成的令牌ID的波束索引。形状为(batch_size*num_return_sequences, sequence_length)tf.Tensor.
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(解码器的每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length).
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 的元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size*num_beams, sequence_length, hidden_size).
  • decoder_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length).
  • cross_attentions (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • decoder_hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 元组(每个生成的令牌一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams, generated_length, hidden_size).

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

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 形状为 (batch_size * num_return_sequence), 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 生成的 sequences 的最终束分数.
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 在每个生成步骤中,每个词汇表标记的处理后的束搜索分数。束搜索分数包括每个词汇表标记的对数softmax分数以及在此束中先前生成的标记的对数softmax的总和。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组,每个张量的形状为 (batch_size*num_beams*num_return_sequences, config.vocab_size).
  • beam_indices (tf.Tensor, 可选, 当传递output_scores=Trueconfig.output_scores=True时返回) — 在每个生成步骤中生成的令牌ID的波束索引。形状为(batch_size*num_return_sequences, sequence_length)tf.Tensor.
  • 注意力 (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size*num_beams, generated_length, hidden_size).

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

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 )

参数

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

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

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 )

参数

  • 序列 (tf.Tensor 形状为 (batch_size, sequence_length)) — 生成的序列。第二维度(sequence_length)要么等于 max_length,要么由于 eos_token_id 而提前结束的所有批次较短。
  • scores (tuple(tf.Tensor) 可选, 当传递 output_scores=Trueconfig.output_scores=True 时返回) — 语言建模头处理后的预测分数(在SoftMax之前的每个词汇标记的分数) 在每个生成步骤。由最多 max_new_tokens 个元素(每个生成的标记一个元素)组成的 tf.Tensor 元组,每个张量的形状为 (batch_size, config.vocab_size).
  • 注意力 (tuple(tuple(tf.Tensor)), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(tf.Tensor)), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 元组(每个生成的标记一个元素)的元组(解码器的每一层一个元素)的 tf.Tensor,形状为 (batch_size, generated_length, hidden_size).

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

FLAX

transformers.generation.FlaxSampleOutput

< >

( sequences: 数组 = 无 )

参数

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

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

替换

< >

( **更新 )

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

transformers.generation.FlaxGreedySearchOutput

< >

( sequences: 数组 = 无 )

参数

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

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

替换

< >

( **更新 )

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

transformers.generation.FlaxBeamSearchOutput

< >

( sequences: 数组 = 无 scores: 数组 = 无 )

参数

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

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

替换

< >

( **更新 )

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

LogitsProcessor

一个 LogitsProcessor 可以用来修改语言模型头部的预测分数以进行生成。

PyTorch

transformers.AlternatingCodebooksLogitsProcessor

< >

( input_start_len: int semantic_vocab_size: int codebook_size: int )

参数

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

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

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

__call__

< >

( input_ids: LongTensor scores: FloatTensor )

transformers.ClassifierFreeGuidanceLogitsProcessor

< >

( guidance_scale )

参数

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

LogitsProcessor 用于分类器自由引导(CFG)。分数在批次维度上分割,其中前半部分对应于条件对数(从输入提示预测),后半部分对应于无条件对数(从空或“空”提示预测)。处理器计算条件和无条件对数的加权平均值,由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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的对数概率;当使用束搜索时,这些可以是每个词汇标记的对数softmax

返回

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

处理后的预测分数。

transformers.EncoderNoRepeatNGramLogitsProcessor

< >

( encoder_ngram_size: int encoder_input_ids: LongTensor )

参数

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

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

它的设计目的是通过防止生成在前几轮对话中出现的n-grams,来促进语言模型的聊天性。

示例:

>>> 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.EncoderRepetitionPenaltyLogitsProcessor

< >

( penalty: float encoder_input_ids: LongTensor )

参数

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

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

它旨在避免在输入基础任务中出现幻觉,例如摘要。虽然最初是为编码器-解码器模型设计的,但它也可以用于仅解码器模型,如LLMs。

示例:

>>> 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.EpsilonLogitsWarper

< >

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

参数

  • epsilon (float) — 如果设置为大于0,则仅保留概率大于或等于epsilon的最可能的标记用于生成。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数。

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

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

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

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

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

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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

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 的值都将被设置为这个浮点值。当需要修改对数概率以排除生成过程中完全不需要的极低概率标记时,此参数非常有用。
  • min_tokens_to_keep (int, 可选, 默认为 1) — 指定生成时必须保留的最小令牌数量,无论它们的概率如何。 例如,如果 min_tokens_to_keep 设置为 1,至少会保留一个令牌用于生成, 即使所有令牌的概率都低于截止值 eta.
  • device (str, optional, defaults to "cpu") — 分配张量的设备。

LogitsProcessor 执行 eta 采样,这是一种过滤掉概率低于动态截止值 eta 的标记的技术,eta 是基于超参数 epsilon 和标记概率的熵的组合计算的,即 eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))。如果没有标记满足此约束,则保留最大的 min_tokens_to_keep 标记。它解决了由神经语言模型生成长文本样本质量差的问题,从而生成更连贯和流畅的文本。有关更多信息,请参阅 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是每个词汇的logits(当不使用束搜索时)或每个词汇标记的log softmax(当使用束搜索时)

返回

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

处理后的预测分数。

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]) — 结束序列标记的id(s)。
  • 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits;当使用束搜索时,这些可以是每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.ForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

LogitsProcessor 强制将指定的标记作为第一个生成的标记。用于编码器-解码器模型。

示例:

>>> 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits;当使用束搜索时,这些可以是每个词汇标记的log softmax

返回

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

处理后的预测分数。

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]) — 结束序列标记的id(s)。
  • device (str, optional, defaults to "cpu") — 分配张量的设备。

LogitsProcessor 在达到 max_length 时强制将指定的标记作为最后生成的标记。

示例:

>>> 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的对数概率;当使用束搜索时,这些可以是每个词汇标记的对数softmax

返回

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

处理后的预测分数。

transformers.HammingDiversityLogitsProcessor

< >

( diversity_penalty: float num_beams: int num_beam_groups: int )

参数

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

LogitsProcessor 用于强制多样化束搜索。

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

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

示例:

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

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

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

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

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

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

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

__call__

< >

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

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax
  • current_tokens (torch.LongTensor of shape (batch_size)) — 词汇表中输入序列标记的索引,对应于当前生成步骤中其他光束组选择的标记。
  • beam_group_idx (int) — 当前正在处理的波束组的索引。

返回

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

处理后的预测分数。

transformers.InfNanRemoveLogitsProcessor

< >

( )

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

这个logits处理器没有generate示例,因为不应该有需要其使用的正确标志组合。

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.LogitNormalization

< >

( )

LogitsProcessor 用于使用log-softmax对分数进行归一化。在应用logits处理器或变形器之后,在beam搜索期间归一化分数非常重要,因为此库中使用的搜索算法不会这样做(它只会在之前进行归一化,但它们可能需要重新归一化),但在比较假设时仍然假设分数是归一化的。

示例:

>>> 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.LogitsProcessor

< >

( )

所有可以在生成过程中应用的对数处理器(logit processors)的抽象基类。

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.LogitsProcessorList

< >

( 可迭代对象 = () )

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

__call__

< >

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

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax
  • kwargs (Dict[str, Any], 可选) — 特定于logits处理器的额外kwargs。

返回

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

处理后的预测分数。

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]) — 结束序列标记的id(s)。
  • device (str, optional, defaults to "cpu") — 分配张量的设备。

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

示例:

>>> 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

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) — 输入令牌的长度。与generate一起使用时不是一个有效的参数,因为它会自动分配输入长度。
  • min_new_tokens (int) — 最小的令牌长度,低于此长度时,eos_token_id的分数将被设置为-float("Inf").
  • eos_token_id (Union[int, List[int], torch.Tensor]) — 结束序列标记的id(s)。
  • device (str, optional, defaults to "cpu") — 分配张量的设备。

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

示例:

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

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

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

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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.MinPLogitsWarper

< >

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

参数

  • min_p (float) — 最小令牌概率,该概率将按最可能令牌的概率进行缩放。它必须是 0到1之间的值。典型值在0.01-0.2范围内,与设置top_p在 0.99-0.8范围内相当选择性(使用与正常top_p值相反的值)。
  • filter_value (float, optional, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值。
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数量。

LogitsProcessor 执行 min-p,即保留所有高于最小概率的标记,该概率由最可能标记的概率进行缩放。因此,在高概率标记存在的情况下,过滤器变得更加激进,这是一个我们不应偏离的自信输出的标志。

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

由 @menhguin 和 @kalomaze(GitHub 用户名)创建。代码改编自 这个外部 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 )

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]]) — 不允许生成的令牌ID列表的列表。
  • eos_token_id (Union[int, List[int], torch.Tensor], optional) — 结束序列标记的id(s)。

LogitsProcessor 用于确保指定的序列永远不会被选择。

为了获取不应出现在生成文本中的单词的token id,请确保在初始化tokenizer时设置add_prefix_space=True,并使用tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space参数仅支持一些慢速tokenizer,因为快速tokenizer的前缀行为来自pre tokenizers。了解更多这里

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

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

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

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


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


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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.NoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

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

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

使用n-gram惩罚时要小心。例如,在一篇关于纽约市的文章中惩罚2-grams(双字组)可能会导致整个文本中城市名称只出现一次的不良结果。 Reference

示例:

>>> 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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是每个词汇的logits(当不使用束搜索时)或每个词汇标记的log softmax(当使用束搜索时)

返回

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

处理后的预测分数。

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]]) — 此函数限制束搜索在每一步仅允许的令牌。此函数接受2个参数inputs_ids和批次IDbatch_id。它必须返回一个列表,其中包含根据先前生成的令牌inputs_ids和批次IDbatch_id条件允许的下一生成步骤的令牌。

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

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

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

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

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

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

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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.RepetitionPenaltyLogitsProcessor

< >

( penalty: float )

参数

  • penalty (float) — 重复惩罚的参数。1.0 表示没有惩罚。大于 1.0 会惩罚之前生成的标记。在 0.0 和 1.0 之间会奖励之前生成的标记。

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

在原始的论文中,作者建议使用大约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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的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]]]) — 将一系列标记映射到其偏差项的列表(例如 [[[10, 45], -2.0], [[64], -7.5]])。正偏差会增加序列被选择的几率,而负偏差则相反。如果序列的长度为1,其偏差将始终被应用。否则,偏差仅在该序列即将完成时应用(在应用此处理器后的标记选择步骤中)。

LogitsProcessor 对序列应用加性偏差。当生成的下一标记可以完成序列时,偏差将应用于序列的最后一个标记。因此,为了充分利用具有多个标记的偏差序列,请考虑使用束搜索方法(以优雅地处理部分完成的序列,这些序列具有负偏差)并将偏差应用于它们的前缀(以确保偏差更早地应用)。

为了获取你想要偏置的序列的token id,请确保在初始化tokenizer时设置add_prefix_space=True,并使用tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space参数仅支持一些慢速tokenizer,因为快速tokenizer的前缀行为来自pre tokenizers。了解更多这里

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM

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

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

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


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


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

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

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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.SuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index device: str = 'cpu' )

SuppressTokensAtBeginLogitsProcessorgenerate 函数开始使用 begin_index 标记生成时,会抑制一系列标记。这应确保由 begin_suppress_tokens 定义的标记不会在开始时生成。最初为 Whisper 创建。

示例:

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

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

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

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

__call__

< >

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

参数

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

返回

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

处理后的预测分数。

transformers.SuppressTokensLogitsProcessor

< >

( suppress_tokens device: str = 'cpu' )

此处理器可用于抑制一系列标记。处理器会将它们的对数概率设置为-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)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是每个词汇的logits(当不使用beam search时)或每个词汇标记的log softmax(当使用beam search时)

返回

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, 可选, 默认为 False) — 是否跳过第一个ngram调用.
  • debug_mode (bool, optional, optional, defaults to False) — Logits 被修改为应用水印修改前的统一值。这是为了测试实现。

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

主要特点:

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

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

  • G值采样: 使用预计算的采样表根据生成的密钥来采样水印值(g值)。

  • 分数调整: 在生成过程中应用计算的g值来修改标记概率,嵌入水印。

  • 上下文重复处理: 包含逻辑以避免在重复上下文中添加水印标记,保持自然性。

  • EOS Token Masking: 支持屏蔽句子结束标记,以防止它们被包含在水印计算中。

  • 实用函数: 提供直接计算g值的函数,检查上下文重复,创建EOS令牌掩码,并估计预期的平均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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.TemperatureLogitsWarper

< >

( temperature: float )

参数

  • temperature (float) — 严格为正的浮点值,用于调节对数分布。小于1的值会减少随机性(反之亦然),0相当于将所有概率质量转移到最可能的标记上。

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

确保在generate参数中包含do_sample=True,否则温度值将不会产生任何效果。

示例:

>>> 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的对数概率;当使用束搜索时,这些可以是每个词汇标记的对数softmax

返回

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

处理后的预测分数。

transformers.TopKLogitsWarper

< >

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

参数

  • top_k (int) — 保留用于 top-k 过滤的最高概率词汇标记的数量。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数量。

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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.TopPLogitsWarper

< >

( top_p: 浮点数 filter_value: 浮点数 = -无穷大 min_tokens_to_keep: 整数 = 1 )

参数

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

LogitsProcessor 执行 top-p,即限制到概率总和为 prob_cut_off <= prob_cut_off 的顶部标记。 通常与 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

transformers.TypicalLogitsWarper

< >

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

参数

  • mass (float, 可选, 默认值为 0.9) — typical_p 的值在 0 到 1 之间,包括 0 和 1,默认值为 0.9.
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数。

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

更多信息请参见Typical Decoding for Natural Language Generation

示例:

>>> 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是每个词汇的logits(当不使用beam search时)或每个词汇标记的log softmax(当使用beam search时)

返回

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

处理后的预测分数。

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 提供的负向提示(如果有的话)充当正向提示。
  • 模型 (PreTrainedModel) — 计算无条件分数的模型。假设与计算条件分数的模型相同。两个模型必须使用相同的分词器。
  • unconditional_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 无条件分支中输入序列标记在词汇表中的索引。如果未设置,将默认为提示的最后一个标记。
  • unconditional_attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于unconditional_ids的注意力掩码。
  • use_cache (bool, optional, 默认为 True) — 是否在负向提示前向传递期间缓存键/值。

用于无分类器引导(CFG)的Logits处理器。该处理器通过guidance_scale参数化,计算来自提示条件和非提示条件(或负面)logits的加权平均分数。非提示条件的分数是通过使用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 )

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): 结束序列标记的ID。 no_timestamps_token_id (int, 可选, 默认为 50363): "<|notimestamps|>"标记的ID。 max_initial_timestamp_index (int, 可选, 默认为 1): 用于设置初始时间戳的最大值。这用于防止模型预测太远的未来时间戳。
  • begin_index (Optional, optional) — 模型生成的第一个令牌的令牌索引。
  • _detect_timestamp_from_logprob (bool, optional) — 是否可以从所有时间戳的logprobs中预测时间戳。

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

更多信息请参见论文

示例:

>>> 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

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, 可选, 可选, 默认为 0.25) — “绿色”令牌使用量与词汇表大小的比率。默认为 0.25.
  • bias (float, optional, optional, defaults to 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, 可选, 默认为 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 of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。What are input IDs?
  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax

返回

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

处理后的预测分数。

TensorFlow

transformers.TFForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

TFLogitsProcessor 强制将指定的标记作为第一个生成的标记。

__call__

< >

( input_ids: Tensor scores: Tensor cur_len: int )

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 )

transformers.TFForceTokensLogitsProcessor

< >

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

该处理器接收一个整数对的列表,这些整数对表示从生成索引到标记索引的映射,这些标记将在采样前被强制使用。处理器会将它们的对数概率设置为0,并将所有其他标记的对数概率设置为-inf,以便它们在相应的索引处被采样。

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFLogitsProcessor

< >

( )

所有可以在生成过程中应用的对数处理器(logit processors)的抽象基类。

__call__

< >

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

参数

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

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

返回

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

处理后的预测分数。

用于处理logits的TF方法。

transformers.TFLogitsProcessorList

< >

( 可迭代对象 = () )

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

__call__

< >

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

参数

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

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

返回

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

处理后的预测分数。

transformers.TFLogitsWarper

< >

( )

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

__call__

< >

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

参数

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

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

返回

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

处理后的预测分数。

用于扭曲logits的TF方法。

class transformers.TFMinLengthLogitsProcessor

< >

( min_length: int eos_token_id: int )

参数

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

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

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFNoBadWordsLogitsProcessor

< >

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

参数

  • bad_words_ids (List[List[int]]) — 不允许生成的标记ID列表。为了获取不应出现在生成文本中的单词的标记,请确保在初始化 分词器时设置add_prefix_space=True,并使用tokenizer(bad_words, add_special_tokens=False).input_idsadd_prefix_space 参数仅支持一些慢速分词器,因为快速分词器的前缀行为来自 pre tokenizers。了解更多here.
  • eos_token_id (int) — 结束序列标记的id.

TFLogitsProcessor 用于确保指定的序列永远不会被采样。

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFNoRepeatNGramLogitsProcessor

< >

( ngram_size: int )

参数

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

TFLogitsProcessor 用于强制不重复n-grams。参见 Fairseq

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFRepetitionPenaltyLogitsProcessor

< >

( penalty: float )

参数

  • repetition_penalty (float) — 重复惩罚的参数。1.0 表示没有惩罚。更多详情请参见 这篇论文.

TFLogitsProcessor 对重复序列实施指数惩罚。

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFSuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index )

TFSuppressTokensAtBeginLogitsProcessorgenerate 函数开始使用 begin_index 标记生成时,会抑制一系列标记。这应确保在生成开始时不会采样由 begin_suppress_tokens 定义的标记。

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFSuppressTokensLogitsProcessor

< >

( suppress_tokens )

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

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFTemperatureLogitsWarper

< >

( temperature: float )

参数

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

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

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFTopKLogitsWarper

< >

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

参数

  • top_k (int) — 保留用于 top-k 过滤的最高概率词汇标记的数量。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数量。

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

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

transformers.TFTopPLogitsWarper

< >

( top_p: 浮点数 filter_value: 浮点数 = -无穷大 min_tokens_to_keep: 整数 = 1 )

参数

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

TFLogitsWarper 执行 top-p,即限制到概率总和小于等于 prob_cut_off 的顶部令牌。

__call__

< >

( input_ids: 张量 scores: 张量 cur_len: 整数 )

FLAX

transformers.FlaxForcedBOSTokenLogitsProcessor

< >

( bos_token_id: int )

参数

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

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxForcedEOSTokenLogitsProcessor

< >

( max_length: int eos_token_id: int )

参数

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

FlaxLogitsProcessor 在达到 max_length 时强制将指定的标记作为最后生成的标记。

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxForceTokensLogitsProcessor

< >

( force_token_map )

参数

  • force_token_map (list) — 映射给出令牌ID和索引,这些令牌将被强制采样。

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxLogitsProcessor

< >

( )

所有可以在生成过程中应用的对数处理器(logit processors)的抽象基类。

__call__

< >

( input_ids: 数组 scores: 数组 ) jnp.ndarray 形状为 (batch_size, config.vocab_size)

参数

  • input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (jnp.ndarray of shape (batch_size, config.vocab_size)) — 语言建模头部的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax
  • kwargs (Dict[str, Any], 可选) — 额外的 logits 处理器特定的 kwargs.

返回

jnp.ndarray 的形状为 (batch_size, config.vocab_size)

处理后的预测分数。

用于处理logits的Flax方法。

transformers.FlaxLogitsProcessorList

< >

( 可迭代对象 = () )

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 **kwargs ) jnp.ndarray 形状为 (batch_size, config.vocab_size)

参数

  • input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

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

返回

jnp.ndarray 形状为 (batch_size, config.vocab_size)

处理后的预测分数。

transformers.FlaxLogitsWarper

< >

( )

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

__call__

< >

( input_ids: 数组 scores: 数组 ) jnp.ndarray 形状为 (batch_size, config.vocab_size)

参数

  • input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用PreTrainedTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (jnp.ndarray of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用束搜索时,这些可以是每个词汇的logits,或者在使用束搜索时,每个词汇标记的log softmax
  • kwargs (Dict[str, Any], 可选) — 额外的 logits 处理器特定的 kwargs.

返回

jnp.ndarray 的形状为 (batch_size, config.vocab_size)

处理后的预测分数。

用于扭曲logits的Flax方法。

transformers.FlaxMinLengthLogitsProcessor

< >

( min_length: int eos_token_id: int )

参数

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

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxSuppressTokensAtBeginLogitsProcessor

< >

( begin_suppress_tokens begin_index )

参数

  • begin_suppress_tokens (List[int]) — 不采样的标记。
  • begin_index (int) — 标记被抑制的索引位置。

FlaxLogitsProcessorgenerate 函数开始生成时,使用 begin_index 标记来抑制一系列标记。这应确保在生成开始时不会采样由 begin_suppress_tokens 定义的标记。

__call__

< >

( input_ids scores cur_len: int )

transformers.FlaxSuppressTokensLogitsProcessor

< >

( suppress_tokens: 列表 )

参数

  • suppress_tokens (list) — 不采样的令牌。

FlaxLogitsProcessor 在每个解码步骤中抑制一系列标记。处理器会将它们的对数概率设置为 -inf,这样它们就不会被采样。

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxTemperatureLogitsWarper

< >

( temperature: float )

参数

  • 温度 (float) — 用于调节对数分布的值。

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxTopKLogitsWarper

< >

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

参数

  • top_k (int) — 保留用于top-k过滤的最高概率词汇标记的数量。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, defaults to 1) — 不能被过滤的最小令牌数。

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

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxTopPLogitsWarper

< >

( top_p: 浮点数 filter_value: 浮点数 = -无穷大 min_tokens_to_keep: 整数 = 1 )

参数

  • top_p (float) — 如果设置为小于1,则仅保留概率之和达到或超过top_p的最小概率集合的令牌用于生成。
  • filter_value (float, 可选, 默认为 -inf) — 所有过滤后的值将被设置为这个浮点数值.
  • min_tokens_to_keep (int, optional, 默认为 1) — 不能被过滤的最小令牌数。

FlaxLogitsWarper 执行 top-p,即限制在概率总和小于等于 prob_cut_off 的顶部令牌。

__call__

< >

( input_ids: 数组 scores: 数组 cur_len: 整数 )

transformers.FlaxWhisperTimeStampLogitsProcessor

< >

( generate_config model_config decoder_input_length )

参数

  • generate_config (GenerateConfig) — 用于生成输出的生成配置。以下参数是必需的: eos_token_id (int, 可选, 默认为 50257): 结束序列标记的ID。 no_timestamps_token_id (int, 可选, 默认为 50363): "<|notimestamps|>"标记的ID。 max_initial_timestamp_index (int, 可选, 默认为 1): 用于设置初始时间戳的最大值。这用于防止模型预测太远的未来时间戳。

Whisper 特定处理器。此处理器可用于强制生成一系列令牌。处理器会将它们的对数概率设置为 inf,以便在相应的索引处进行采样。

__call__

< >

( input_ids scores cur_len )

停止条件

一个StoppingCriteria可以用来改变何时停止生成(除了EOS标记)。请注意,这仅适用于我们的PyTorch实现。

transformers.StoppingCriteria

< >

( )

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

如果你的停止标准依赖于scores输入,请确保你传递return_dict_in_generate=True, output_scores=Truegenerate

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], optional) — 特定停止标准的额外关键字参数。

transformers.StoppingCriteriaList

< >

( 可迭代对象 = () )

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], 可选) — 特定于额外停止标准的kwargs.

transformers.MaxLengthCriteria

< >

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

参数

  • max_length (int) — 输出序列的最大长度,以令牌数量表示。
  • max_position_embeddings (int, optional) — 模型的最大长度,由模型的config.max_position_embeddings属性定义。

此类可用于在生成的令牌总数超过max_length时停止生成。请记住,对于仅解码器类型的变压器,这将包括初始提示的令牌。

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], optional) — 特定停止标准的额外关键字参数。

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 of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], 可选) — 特定于额外停止标准的kwargs。

transformers.StopStringCriteria

< >

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

参数

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

该类可用于在生成特定字符串序列时停止生成。它与分词器词汇表一起预处理字符串,以找到可以有效地完成停止字符串的标记位置。

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

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

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

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

这些不匹配的原因是停止字符串与最终标记不重叠。如果你可以从序列的末尾移除一个或多个标记而不破坏停止字符串,那么这个标准将不会匹配该停止字符串。这是设计上的考虑;因为每次生成标记后都会运行此检查,如果生成了有效的停止字符串,我们不会错过它,但我们不希望仅仅因为停止字符串存在于过去的input_ids中而停止生成。

匹配实际上是如何进行的呢?我们以一种相当令人困惑的方式进行,因为我们希望整个匹配过程能够与Torch或XLA兼容,这意味着我们不能使用标准的字符串方法。然而,通过一些工作,可以使用纯张量操作进行字符串匹配。我们将首先描述我们使用的标准字符串操作算法,然后在最后解释如何将其转换为纯张量操作。

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

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

构造一个不满足此属性的匹配序列是不可能的(可以自行验证)。然而,尽管最终标记的开始与停止字符串的结束之间的这种重叠对于匹配是必要的,但这并不足够。我们还需要检查标记序列的其余部分是否与停止字符串一致。

我们如何做到这一点?让我们以[“s”, “to”, “pped”]为例。我们知道,最后一个标记“pped”与停止字符串“stop”有1个字符的重叠。然后我们回到前一个标记“to”。由于我们已经匹配了停止字符串的1个字符,剩下的需要检查的是“sto”。我们检查下一个标记“to”是否与剩余部分的末尾匹配,确实匹配。现在我们已经匹配了停止字符串的3个字符,剩下的需要匹配的是“s”。我们再次回到前一个标记,也是“s”。这是一个匹配,因此我们已经匹配了整个停止字符串。

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

我们如何通过张量操作计算这些匹配呢?简单来说:我们高效地预先计算所有标记的必要信息!对于每个标记,我们计算:

  • 它与停止字符串末尾的重叠(如果有的话)
  • 停止字符串内令牌匹配的位置,包括从开头开始的匹配。
  • 令牌的总长度

例如,对于标记“pped”,我们将计算一个结束重叠为1,没有内部匹配位置,长度为4。对于标记“to”,我们将计算没有结束重叠,一个内部匹配位置为1(从末尾开始计数),长度为2。对于标记“s”,我们将计算没有结束重叠,一个内部匹配位置为3(再次从末尾开始计数),长度为1。

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

  • 检查最后一个标记是否与起始字符串有结束重叠
  • 继续向后查找,同时记录到目前为止我们已经匹配了多少停止字符串
  • 在每一点,检查下一个标记是否将当前位置作为其有效位置之一
  • 继续直到匹配失败,或者我们完全匹配整个停止字符串

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

在第二种情况下,[“las”, “topper”],“topper”有3个字符的结尾重叠,所以我们可以开始匹配。到目前为止,我们已经匹配了3个字符,所以我们检查下一个标记“las”是否有3作为一个有效的位置。确实有,因为我们允许标记匹配超出停止字符串起始位置的位置。我们将其长度添加到位置跟踪器中。位置跟踪器现在为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 of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], optional) — 特定停止条件的额外关键字参数。

transformers.EosTokenCriteria

< >

( eos_token_id: typing.Union[int, typing.List[int], torch.Tensor] )

参数

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

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

__call__

< >

( input_ids: LongTensor scores: FloatTensor **kwargs )

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • scores (torch.FloatTensor of shape (batch_size, config.vocab_size)) — 语言建模头的预测分数。这些可以是SoftMax之前每个词汇标记的分数 或SoftMax之后每个词汇标记的分数。如果此停止标准依赖于scores输入, 请确保传递return_dict_in_generate=True, output_scores=Truegenerate.
  • kwargs (Dict[str, Any], 可选) — 特定停止标准的额外关键字参数。

约束条件

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

transformers.Constraint

< >

( )

所有在生成过程中可以应用的约束的抽象基类。 它必须定义如何满足约束。

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

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

将始终终止(停止)。

前进

< >

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

返回

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

  • 一个单一的令牌ID(整数),用于推进约束,或者
  • 一个可以推进约束的令牌ID列表
  • 如果约束已完成或无法推进,则为None

当被调用时,返回会使此约束更接近满足的token(s)。

复制

< >

( stateful = False ) 约束(Constraint)

参数

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

返回

约束(Constraint)

与正在调用的约束相同。

创建此约束的新实例。

does_advance

< >

( token_id: int )

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

剩余

< >

( )

返回完成此约束所需的advance()剩余步骤数。

重置

< >

( )

将此约束的状态重置为其初始化状态。我们会在约束的满足被不想要的令牌中断的情况下调用此方法。

测试

< >

( )

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

更新

< >

( token_id: int ) stepped(bool)

参数

  • token_id(int) — 在束搜索中新生成的令牌的id。

返回

步进(bool)

这个约束是否已经更接近实现。 completed(bool): 这个约束是否已经通过生成这个令牌完全实现。 reset (bool): 这个约束是否通过生成这个令牌重置了其进度。

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

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

transformers.PhrasalConstraint

< >

( token_ids: typing.List[int] )

参数

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

Constraint 强制要求输出中包含一个有序的标记序列。

transformers.DisjunctiveConstraint

< >

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

参数

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

一种特殊的约束,只需满足多个约束中的一个即可实现。

transformers.ConstraintListState

< >

( 约束条件: typing.List[transformers.generation.beam_constraints.Constraint] )

参数

  • 约束条件 (List[Constraint]) — 必须由光束评分器满足的Constraint对象列表。

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

前进

< >

( )

生成的令牌列表,以便我们能够取得进展。 这里的“列表”并不是指完全满足约束条件的令牌列表。

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

[t_k1 for k in indices of unfulfilled constraints]

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

虽然我们不关心哪个约束条件首先被满足,但如果我们在满足一个约束条件的过程中,我们只会返回那个约束条件。

重置

< >

( token_ids: typing.Optional[typing.List[int]] )

token_ids: 迄今为止生成的令牌,用于重置通过约束的进度状态。

BeamSearch

transformers.BeamScorer

< >

( )

所有用于~PreTrainedModel.beam_search~PreTrainedModel.beam_sample的beam scorers的抽象基类。

进程

< >

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

参数

  • input_ids (torch.LongTensor of shape (batch_size * num_beams, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    索引可以通过继承自PreTrainedTokenizer的任何类获得。详情请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • next_scores (torch.FloatTensor of shape (batch_size, 2 * num_beams)) — 当前未完成的波束假设的前 2 * num_beams 个得分。
  • next_tokens (torch.LongTensor of shape (batch_size, 2 * num_beams)) — input_ids 对应的前 2 * num_beams 个未完成的束假设的标记。
  • next_indices (torch.LongTensor of shape (batch_size, 2 * num_beams)) — 表示next_tokens对应的波束假设的波束索引。
  • pad_token_id (int, optional) — padding 标记的 ID。
  • eos_token_id (Union[int, List[int]], optional) — 结束序列标记的ID。可选地,使用列表来设置多个结束序列标记。
  • beam_indices (torch.LongTensor, optional) — 表示每个标记对应的波束假设的波束索引。
  • group_index (int, 可选) — 光束组的索引。与 ~PreTrainedModel.group_beam_search 一起使用。

返回

UserDict

由上述定义的字段组成的字典:

  • next_beam_scores (torch.FloatTensor of shape (batch_size * num_beams)) — 所有未完成beam的更新分数。
  • next_beam_tokens (torch.FloatTensor of shape (batch_size * num_beams)) — 将要添加到未完成beam_hypotheses的下一个tokens。
  • next_beam_indices (torch.FloatTensor of shape (batch_size * num_beams)) — 指示下一个tokens应添加到哪个beam的beam索引。

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 of shape (batch_size * num_beams, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    索引可以通过任何继承自PreTrainedTokenizer的类获得。详情请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • final_beam_scores (torch.FloatTensor of shape (batch_size * num_beams)) — 所有未完成beam的最终分数。
  • final_beam_tokens (torch.FloatTensor of shape (batch_size * num_beams)) — 最后添加到未完成的beam_hypotheses的令牌。
  • final_beam_indices (torch.FloatTensor of shape (batch_size * num_beams)) — 指示final_beam_tokens应添加到哪个波束的波束索引。
  • pad_token_id (int, 可选) — 填充 token 的 id.
  • eos_token_id (Union[int, List[int]], optional) — 结束序列标记的ID。可选地,使用列表来设置多个结束序列标记。

返回

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

生成的序列。 第二维度(sequence_length)要么等于max_length,要么如果所有批次由于eos_token_id提前结束则较短。

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

BeamScorer 实现标准束搜索解码。

部分改编自 Facebook’s XLM beam search code.

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

进程

< >

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

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

BeamScorer 实现约束束搜索解码。

进程

< >

( 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 (torch.LongTensor of shape (batch_size * num_beams, sequence_length)) — Indices of input sequence tokens in the vocabulary.

    索引可以通过任何继承自PreTrainedTokenizer的类获得。详情请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • next_scores (torch.FloatTensor of shape (batch_size, 2 * num_beams)) — 当前未完成的 2 * num_beams 个光束假设的分数。
  • next_tokens (torch.LongTensor of shape (batch_size, 2 * num_beams)) — input_ids 对应的前 2 * num_beams 个未完成的束假设的标记。
  • next_indices (torch.LongTensor of shape (batch_size, 2 * num_beams)) — 指示next_tokens对应的波束假设的波束索引。
  • scores_for_all_vocab (torch.FloatTensor of shape (batch_size * num_beams, sequence_length)) — 词汇表中所有令牌的分数,针对每个光束假设。
  • pad_token_id (int, optional) — padding 标记的 ID。
  • eos_token_id (Union[int, List[int]], optional) — 序列结束标记的ID。可选地,使用列表来设置多个序列结束标记。
  • beam_indices (torch.LongTensor, optional) — 表示每个标记对应的波束假设的波束索引。
  • decoder_prompt_len (int, optional) — 包含在解码器输入中的提示长度。

返回

UserDict

由上述定义的字段组成的字典:

  • next_beam_scores (torch.FloatTensor of shape (batch_size * num_beams)) — 所有未完成光束的更新分数。

  • next_beam_tokens (torch.FloatTensor of shape (batch_size * num_beams)) — 将要添加到未完成光束假设中的下一个标记。

  • next_beam_indices (torch.FloatTensor of shape (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 )

流处理器

transformers.TextStreamer

< >

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

参数

  • tokenizer (AutoTokenizer) — 用于解码标记的标记化工具。
  • skip_prompt (bool, 可选, 默认为 False) — 是否跳过提示到 .generate()。例如,对于聊天机器人很有用。
  • decode_kwargs (dict, 可选) — 传递给分词器的 decode 方法的额外关键字参数。

简单的文本流处理器,一旦形成完整的单词,就会将标记打印到标准输出。

流媒体类的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,

结束

< >

( )

刷新所有剩余的缓存并在标准输出中打印一个新行。

on_finalized_text

< >

( 文本: str 流结束: bool = False )

将新文本打印到标准输出。如果流结束,还会打印一个换行符。

put

< >

( )

接收令牌,解码它们,并在它们形成完整单词时立即将它们打印到标准输出。

transformers.TextIteratorStreamer

< >

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

参数

  • tokenizer (AutoTokenizer) — 用于解码标记的标记化器。
  • skip_prompt (bool, 可选, 默认为 False) — 是否跳过提示到 .generate()。例如,对于聊天机器人很有用。
  • timeout (float, 可选) — 文本队列的超时时间。如果为 None,队列将无限期阻塞。在 .generate() 中处理异常时非常有用,当它在单独的线程中调用时。
  • decode_kwargs (dict, optional) — 传递给分词器的decode方法的额外关键字参数。

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

流媒体类的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

< >

( 文本: str 流结束: bool = False )

将新文本放入队列中。如果流即将结束,也在队列中放入一个停止信号。

缓存

transformers.Cache

< >

( )

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

更新

< >

( 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) — 缓存子类的额外参数。这些参数特定于每个子类,并允许创建新类型的缓存。

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

transformers.CacheConfig

< >

( cache_implementation: 无 )

缓存配置的基类

更新

< >

( **kwargs ) Dict[str, Any]

参数

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

返回

Dict[str, Any]

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

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

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

量化缓存设置的配置类。

验证

< >

( )

验证传递的参数是否正确

transformers.DynamicCache

< >

( num_hidden_layers: typing.Optional[int] = None )

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

它将键和值状态存储为一系列张量,每个层一个。每个张量的预期形状是 [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()

更新

< >

( 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中没有使用额外的参数。

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

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 num_hidden_layers: int = None )

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

transformers.QuantizedCache

< >

( cache_config: QuantizedCacheConfig )

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

缓存有两种类型的存储,一种用于原始精度,另一种用于量化缓存。设置了一个residual length作为原始精度缓存的最大容量。当长度超过最大容量时,原始精度缓存将被丢弃并转移到量化缓存中。量化是按通道进行的,为Keys和Values设置了一个q_group_size,与论文中描述的不同。

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

更新

< >

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

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

transformers.QuantoQuantizedCache

< >

( cache_config: CacheConfig )

参数

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

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

示例:

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

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

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

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

transformers.HQQQuantizedCache

< >

( cache_config: CacheConfig )

参数

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

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

示例:

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

transformers.SinkCache

< >

( window_length: int num_sink_tokens: int )

参数

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

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

它将键和值状态存储为一系列张量,每个层一个。每个张量的预期形状是 [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()

更新

< >

( 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中使用:sin, cospartial_rotation_size。这些参数用于使用RoPE的模型,以在令牌移位时重新计算旋转。

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

get_seq_length

< >

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

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

reorder_cache

< >

( beam_idx: LongTensor )

根据选定的光束索引重新排序缓存以进行光束搜索。

transformers.OffloadedCache

< >

( )

DynamicCache 的替代方案,通过牺牲更多的 CPU 内存来节省 GPU 内存。 适用于从具有非常长上下文的模型生成。

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

更新

< >

( 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中没有使用额外的参数。

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

prefetch_layer

< >

( layer_idx: int )

开始预取下一层缓存

evict_previous_layer

< >

( layer_idx: int )

将前一层缓存移动到CPU

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) — 模型将使用的最大序列长度。
  • 设备 (torch.devicestr) — 缓存应初始化的设备。应与层相同。
  • 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(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()

更新

< >

( 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输入 以知道在缓存中的写入位置。

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

get_seq_length

< >

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

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

重置

< >

( )

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

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]) — 缓存应初始化的设备。应与层设备相同。
  • dtype (torch.dtype, 可选) — 初始化缓存时使用的默认 dtype
  • offload_device (Union[str, torch.device], 可选, 默认为 cpu) — 要卸载到的设备。默认为CPU.
  • layer_device_map (Dict[int, Union[str, torch.device, int]], optional) — 层与其设备之间的映射。当您手动初始化缓存并且模型分布在不同的GPU上时,这是必需的。 您可以通过检查相关的device_map来了解哪些层映射到哪些设备:model.hf_device_map.
  • key_cache (List[torch.Tensor]) — 卸载的键缓存张量。第一个将在设备上,而其他的是 卸载的。
  • value_cache (List[torch.Tensor]) — 卸载的值缓存张量。第一个将在设备上,而其他的则被卸载。
  • max_batch_size (int) — 此缓存可以使用的最大批量大小。
  • max_cache_len (int) — 此缓存可以使用的最大序列长度。
  • device (torch.device) — 缓存使用的设备。
  • offload_device (torch.device) — 用于卸载的设备。
  • dtype (torch.dtype) — 用于初始化缓存的dtype.

静态缓存类,用于与torch.compile(model)一起使用,将工作负载转移到CPU或其他设备上。

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, OffloadedStaticCache

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

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

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

更新

< >

( 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 输入以知道在缓存中的写入位置。

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

get_seq_length

< >

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

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

重置

< >

( )

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

transformers.HybridCache

< >

( config: PretrainedConfig batch_size: int = None max_cache_len: int = None device: typing.Union[torch.device, str] = 'cpu' 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.device or str, optional, defaults to "cpu") — 缓存应初始化的设备。应与层相同。
  • 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一起使用的混合缓存类,适用于Gemma2模型,这些模型在每一层之间交替使用局部滑动窗口注意力和全局注意力。在底层,混合缓存利用[“SlidingWindowCache”]进行滑动窗口注意力,利用[“StaticCache”]进行全局注意力。更多信息,请参阅每个子组件缓存类的文档。

示例:

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, HybridCache

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

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

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

更新

< >

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

重置

< >

( )

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

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) — 模型将使用的最大序列长度。
  • 设备 (torch.devicestr) — 缓存应初始化的设备。应与层相同。
  • 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, 如果为真(这意味着由于滑动窗口的限制,缓存无法同时保存所有旧的键值状态和新的状态), 我们需要根据indices进行循环移位,以用传入的新键值状态替换最旧的状态。

只有当我们在滑动窗口之上时,to_shift 才为真。因此,当 sliding_window==64 时:

索引 = (切片 + 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()

更新

< >

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

重置

< >

( )

transformers.EncoderDecoderCache

< >

( self_attention_cache: 缓存 cross_attention_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

重置

< >

( )

reorder_cache

< >

( beam_idx: LongTensor )

根据选定的光束索引重新排序缓存以进行光束搜索。

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.
  • 设备 (torch.devicestr, 可选) — 缓存应初始化的设备。应与层相同。
  • dtype — (torch.dtype): 用于初始化缓存的默认 dtype.
  • intermediate_size — (int): 模型的 intermediate_size 取自配置。
  • ssm_state_size — (int): 模型的状态大小取自配置。
  • conv_kernel_size — (int): 模型的卷积核大小取自配置
  • conv_states — (torch.Tensor): 一个形状为 [layer_idx, batch_size, intermediate_size, conv_kernel_size] 的张量,用于保存卷积状态。
  • ssm_states — (torch.Tensor): 一个形状为 [layer_idx, batch_size, intermediate_size, ssm_state_size] 的张量,用于保存 ssm 状态

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

示例:

>>> from transformers import AutoTokenizer, MambaForCausalLM, MambaCache

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

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

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

update_conv_state

< >

( layer_idx: int new_conv_state: Tensor cache_position: LongTensor )

update_ssm_state

< >

( layer_idx: int new_ssm_state: Tensor )

重置

< >

( )

水印工具

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。
  • 偏差 (float): 用于水印处理。添加到所选“绿色”标记的logits的偏差。默认为2.0。
  • hashing_key (int): 用于水印的哈希键。默认为15485863(第100万个质数)。
  • seeding_scheme (str): 用于水印的算法。接受以下值:
    • “lefthash”(默认):选择“绿色”标记取决于最后一个标记(论文中的算法2)
    • “selfhash”:选择“绿色”标记取决于当前标记本身(论文中的算法3) 此方案的缺点是它考虑了所有可能的下一个标记,可能比“lefthash”慢。
  • context_width(int): 用于种子生成的先前标记的上下文长度。更高的上下文长度使水印更加稳健。

__call__

( *args **kwargs )

将自身作为函数调用。

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, optional, defaults to False) — 是否只计算每个唯一的ngram一次。
  • max_cache_size (int, optional, 默认为 128) — 用于每个令牌调用的种子/采样算法的LRU缓存的最大大小。

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

更多信息请参见论文

示例:

>>> 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 阈值会降低灵敏度,而较低的 z 阈值则会提高灵敏度。
  • return_dict (bool, 可选, 默认为 False) — 是否返回 ~generation.WatermarkDetectorOutput。如果不返回,将返回布尔预测,

返回

WatermarkDetectorOutputnp.array

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

ma

transformers.BayesianDetectorConfig

< >

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

参数

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

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

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

transformers.BayesianDetectorModel

< >

( config )

参数

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

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

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

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

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

该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。

前进

< >

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

参数

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

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

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) — Ngram长度.
  • keys (List[int]) — 一系列水印密钥,每个深度一个。
  • context_history_size (int, 可选, 默认为 1024) — 用于跟踪已见上下文的张量大小。
  • sampling_table_seed (int, optional, 默认为 0) — 用于生成采样表的随机种子。
  • sampling_table_size (int, optional, defaults to 65536) — 采样表的大小.
  • skip_first_ngram_calls (bool, 可选, 默认为 False) — 是否跳过第一个ngram调用.
  • debug_mode (bool, optional, optional, defaults to 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)

transformers.SynthIDTextWatermarkDetector

< >

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

参数

  • detector_module (BayesianDetectorModel) — 贝叶斯检测器模块对象,已使用参数初始化。 查看 examples/research_projects/synthid_text/detector_training.py 以了解使用方法。
  • logits_processor (SynthIDTextWatermarkLogitsProcessor) — 用于水印处理的logits处理器。
  • tokenizer (Any) — 用于模型的tokenizer。

SynthID 文本水印检测器类。

此类需要使用训练好的贝叶斯检测器模块检查脚本进行初始化,例如在训练/保存/加载此检测器模块时,可以参考examples/synthid_text/detector_training.py中的示例。该文件夹还展示了此检测器的示例用例。

示例:

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

>>> # Load the detector. See examples/research_projects/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: 张量 )

编译工具

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, optional, defaults to "reduce-overhead") — 控制性能和开销之间的平衡。
  • options (dict, optional) — 一个传递给后端的选项字典。

该类包含与torch.compile行为相关的参数,当在generate中使用自动编译时。 有关参数的更多详细信息,请参见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 )

将自身作为函数调用。

< > Update on GitHub