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

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

TensorFlow

class transformers.generation.TFGreedySearchEncoderDecoderOutput

<来源>

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

参数

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

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

class transformers.generation.TFGreedySearchDecoderOnlyOutput

<来源>

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

参数

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

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

class transformers.generation.TFSampleEncoderDecoderOutput

<来源>

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

参数

• sequences (tf.Tensor，形状为(batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则较短。
  
• scores (tuple(tf.Tensor) optional, 当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤的语言建模头的处理预测分数（SoftMax 之前每个词汇标记的分数）。具有最多max_new_tokens元素的tf.Tensor元组（每个生成的标记一个元素），每个张量的形状为(batch_size*num_return_sequences, config.vocab_size)。
  
• encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size*num_return_sequences, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个解码器层一个）。
  
• encoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size*num_return_sequences, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
  
• decoder_attentions (tuple(tuple(tf.Tensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每一层一个元素）的tf.Tensor，形状为(batch_size*num_return_sequences, num_heads, generated_length, sequence_length)。
  
• cross_attentions (tuple(tuple(tf.Tensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每一层一个元素）的tf.Tensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• decoder_hidden_states (tuple(tuple(tf.Tensor)), optional, 当传递output_hidden_states=True或config.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属性）访问解码器（或编码器）的隐藏状态和注意力权重。

class transformers.generation.TFSampleDecoderOnlyOutput

<来源>

( sequences: Tensor = None scores: Optional = None attentions: Optional = None hidden_states: Optional = 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=True或config.output_scores=True时返回) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）在每个生成步骤。tf.Tensor的元组，最多有max_new_tokens个元素（每个生成的标记一个元素），每个张量的形状为(batch_size*num_return_sequences, config.vocab_size)。
  
• attentions (tuple(tuple(tf.Tensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每一层一个元素）的tf.Tensor，形状为(num_return_sequences*batch_size, num_heads, generated_length, sequence_length)。
  
• hidden_states (tuple(tuple(tf.Tensor)), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每一层一个元素）的tf.Tensor，形状为(num_return_sequences*batch_size, generated_length, hidden_size)。
  

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

class transformers.generation.TFBeamSearchEncoderDecoderOutput

<来源>

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

参数

• sequences (tf.Tensor，形状为(batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则要短。
  
• sequences_scores (tf.Tensor，形状为(batch_size*num_return_sequences)，optional, 当传递output_scores=True或config.output_scores=True时返回) — 生成的sequences的最终 beam 分数。
  
• scores (tuple(tf.Tensor)，optional, 当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中每个词汇标记的处理过的 beam 分数。beam 分数由每个词汇标记的 log softmax 分数和此 beam 中先前生成标记的 log softmax 之和组成。tf.Tensor的元组，最多有max_new_tokens个元素（每个生成的标记一个元素），每个张量的形状为(batch_size*num_beams, config.vocab_size)。
  
• beam_indices (tf.Tensor，optional, 当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中生成的标记 id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的tf.Tensor。
  
• encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（解码器每一层一个）。
  
• encoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
  
• decoder_attentions（tuple(tuple(tf.Tensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每层一个元素）的tf.Tensor，形状为(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)。
  
• cross_attentions（tuple(tuple(tf.Tensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每层一个元素）的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时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每层一个元素）的tf.Tensor，形状为(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)。
  

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

class transformers.generation.TFBeamSearchDecoderOnlyOutput

<来源>

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

参数

• sequences（形状为(batch_size*num_return_sequences, sequence_length)的tf.Tensor）— 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则要短。
  
• sequences_scores（形状为(batch_size*num_return_sequences)的tf.Tensor，可选，当传递output_scores=True或config.output_scores=True时返回）— 生成的sequences的最终 beam 分数。
  
• scores（tuple(tf.Tensor) 可选，当传递output_scores=True或config.output_scores=True时返回）— 每个生成步骤中每个词汇标记的处理过的 beam 分数。beam 分数由每个词汇标记的 log softmax 分数和此 beam 中先前生成的标记的 log softmax 之和组成。具有最多max_new_tokens元素的tf.Tensor元组（每个生成的 token 一个元素），每个张量的形状为(batch_size*num_beams*num_return_sequences, config.vocab_size)。
  
• beam_indices（tf.Tensor，可选，当传递output_scores=True或config.output_scores=True时返回）— 每个生成步骤中生成的 token id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的tf.Tensor。
  
• attentions（tuple(tuple(tf.Tensor))，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每层一个元素）的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时返回）— 元组（每个生成的 token 一个元素）的元组（解码器每层一个元素）的tf.Tensor，形状为(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)。
  

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

class transformers.generation.TFBeamSampleEncoderDecoderOutput

<来源>

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

参数

• sequences (tf.Tensor，形状为(batch_size*num_beams, sequence_length)) — 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则较短。
  
• sequences_scores (tf.Tensor，形状为(batch_size * num_return_sequence)，optional，当传递output_scores=True或config.output_scores=True时返回) — 生成的sequences的最终 beam 分数。
  
• scores (tuple(tf.Tensor)，optional，当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中每个词汇标记的处理 beam 分数。beam 分数由每个词汇标记的 log softmax 分数和此 beam 中先前生成标记的 log softmax 之和组成。具有最多max_new_tokens元素的tf.Tensor元组（每个生成的标记一个元素），每个张量形状为(batch_size*num_beams, config.vocab_size)。
  
• beam_indices (tf.Tensor，optional，当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中生成的标记 id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的tf.Tensor。
  
• encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个解码器层一个）。
  
• encoder_hidden_states (tuple(tf.Tensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size*num_beams, sequence_length, hidden_size)的tf.Tensor元组（嵌入输出和每个层输出各一个）。
  
• decoder_attentions (tuple(tuple(tf.Tensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（每个解码器层一个）的tf.Tensor，形状为(batch_size*num_beams, num_heads, generated_length, sequence_length)。
  
• cross_attentions (tuple(tuple(tf.Tensor))，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（每个解码器层一个）的tf.Tensor，形状为(batch_size, num_heads, generated_length, sequence_length)。
  
• decoder_hidden_states (tuple(tuple(tf.Tensor))，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组（每个生成的标记一个元素）的元组（每个解码器层一个）的tf.Tensor，形状为(batch_size*num_beams, generated_length, hidden_size)。
  

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

class transformers.generation.TFBeamSampleDecoderOnlyOutput

<来源>

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

参数

• sequences (tf.Tensor，形状为(batch_size*num_return_sequences, sequence_length)) — 生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则较短。
  
• sequences_scores (tf.Tensor，形状为(batch_size * num_return_sequence)，optional，当传递output_scores=True或config.output_scores=True时返回) — 生成的sequences的最终 beam 分数。
  
• scores (tuple(tf.Tensor) optional, 当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中每个词汇标记的处理 beam 分数。beam 分数由每个词汇标记的 log softmax 分数和此 beam 中先前生成的标记的 log softmax 之和组成。具有最多max_new_tokens元素的tf.Tensor元组（每个生成的标记一个元素），每个张量的形状为(batch_size*num_beams*num_return_sequences, config.vocab_size)。
  
• beam_indices (tf.Tensor, optional, 当传递output_scores=True或config.output_scores=True时返回) — 每个生成步骤中生成的标记 id 的 beam 索引。形状为(batch_size*num_return_sequences, sequence_length)的tf.Tensor。
  
• attentions (tuple(tuple(tf.Tensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每层一个元素）的tf.Tensor，形状为(batch_size*num_beams, num_heads, generated_length, sequence_length)。
  
• hidden_states (tuple(tuple(tf.Tensor)), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组（每个生成的标记一个元素）的元组（解码器每层一个元素）的tf.Tensor，形状为(batch_size*num_beams, generated_length, hidden_size)。
  

用于使用 beam sample 的仅解码器生成模型的输出的基类。

class transformers.generation.TFContrastiveSearchEncoderDecoderOutput

<来源>

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

参数

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

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

class transformers.generation.TFContrastiveSearchDecoderOnlyOutput

<来源>

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

参数

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

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

FLAX

class transformers.generation.FlaxSampleOutput

<来源>

( sequences: Array = None )

参数

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

Flax 基类，用于仅使用抽样生成模型的输出。

替换

<来源>

( **updates )

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

class transformers.generation.FlaxGreedySearchOutput

<来源>

( sequences: Array = None )

参数

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

Flax 基类，用于仅使用贪婪搜索生成模型的输出。

替换

<来源>

( **updates )

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

class transformers.generation.FlaxBeamSearchOutput

<来源>

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

参数

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

Flax 基类，用于仅使用贪婪搜索生成模型的输出。

替换

<来源>

( **updates )

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

LogitsProcessor

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

PyTorch

class transformers.AlternatingCodebooksLogitsProcessor

<来源>

( input_start_len: int semantic_vocab_size: int codebook_size: int )

参数

• input_start_len（int）— 初始输入序列的长度。
  
• semantic_vocab_size（int）— 语义部分的词汇表大小，即与语义词汇表相关联的标记数。
  
• codebook_size（int）— 与代码簿相关联的标记数。
  

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

此对数处理器仅与Bark的精细子模型兼容。请参阅模型文档以获取示例。

__call__

<来源>

( input_ids: LongTensor scores: FloatTensor )

class transformers.ClassifierFreeGuidanceLogitsProcessor

<来源>

( guidance_scale )

参数

• guidance_scale（浮点数）— 用于分类器自由引导（CFG）的引导比例。通过设置guidance_scale > 1来启用 CFG。更高的引导比例鼓励模型生成与输入提示更紧密相关的样本，通常以牺牲质量为代价。

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

有关更多信息，请参阅论文。

此对数处理器仅与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 ) → export const metadata = 'undefined';torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。什么是输入 ID？
  
• scores（形状为(batch_size, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数。当不使用波束搜索时，这些可以是每个词汇表的对数，或者在使用波束搜索时，可以是每个词汇表标记的对数 softmax
  

返回

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

处理后的预测分数。

class transformers.EncoderNoRepeatNGramLogitsProcessor

<来源>

( encoder_ngram_size: int encoder_input_ids: LongTensor )

参数

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

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

它旨在通过阻止生成先前对话轮中存在的 n-gram 来促进语言模型中的喋喋不休。

示例：

>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt")
>>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one.
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: I love cats. What do you
>>> # With this logits processor, we can prevent Bob from repeating Alice's opinion.
>>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: My cats are very cute.

__call__

<来源>

( input_ids: LongTensor scores: FloatTensor ) → export const metadata = 'undefined';torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

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

返回

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

处理后的预测分数。

class transformers.EncoderRepetitionPenaltyLogitsProcessor

< source >

( penalty: float encoder_input_ids: LongTensor )

参数

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

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__

< source >

( input_ids: LongTensor scores: FloatTensor ) → export const metadata = 'undefined';torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

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

返回

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

处理后的预测分数。

class transformers.EpsilonLogitsWarper

< source >

( 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，可选，默认为 1) — 不能被过滤的最小标记数。
  

LogitsWarper 执行 epsilon-sampling，即限制到概率 prob >= epsilon 的标记。如果没有标记满足此约束，则取最大的 min_tokens_to_keep 个标记。有关更多信息，请参阅截断抽样作为语言模型去平滑。

示例：

>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
>>> set_seed(0)
>>> model = AutoModelForCausalLM.from_pretrained("distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("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, 0, 2, 2. 2, 2, 2, 2
>>> # 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__

< source >

( input_ids: LongTensor scores: FloatTensor ) → export const metadata = 'undefined';torch.FloatTensor of shape (batch_size, config.vocab_size)

参数

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

返回

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

处理后的预测分数。

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