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

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

class transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor

<来源>

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

参数

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

用于无分类器引导（CFG）的 Logits 处理器。处理器通过guidance_scale参数化的 prompt 条件和 prompt 无条件（或负）logits 的分数进行加权平均。无条件分数是通过提示model使用unconditional_ids分支内部计算的。

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

示例：

>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> model = AutoModelForCausalLM.from_pretrained("gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("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"
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

__call__

<来源>

( input_ids scores )
• 1

class transformers.WhisperTimeStampLogitsProcessor

<来源>

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

参数

• generate_config（GenerateConfig）–用于生成输出的生成配置。需要以下参数：eos_token_id（int，optional，默认为 50257）：sequence结束标记的 id。no_timestamps_token_id（int，optional，默认 50363）："<|notimestamps|>"令牌。max_initial_timestamp_index（int，optional，默认 1）的 id：用于设置初始时间戳的最大值。这用于防止模型预测未来太远的时间戳。
  
• begin_index（Optional，可选）— 模型生成的第一个标记的标记索引。
  
• _detect_timestamp_from_logprob（bool，可选）— 是否可以从所有时间戳的 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
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

__call__

<来源>

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

参数

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

返回

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

处理后的预测分数。

TensorFlow

class transformers.TFForcedBOSTokenLogitsProcessor

<来源>

( bos_token_id: int )
• 1

参数

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

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFForcedEOSTokenLogitsProcessor

<来源>

( max_length: int eos_token_id: int )
• 1

参数

• max_length（int）— 要生成的序列的最大长度。
  
• eos_token_id（int）— 在达到max_length时强制作为最后生成的标记的标记 ID。
  

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFForceTokensLogitsProcessor

<来源>

( force_token_map: List )
• 1

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFLogitsProcessor

<来源>

( )
• 1

用于在生成过程中应用的所有 logit 处理器的抽象基类。

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int ) → export const metadata = 'undefined';tf.Tensor of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 获取索引。详情请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (tf.Tensor，形状为(batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时，这些可以是每个词汇表的 logits，或者在使用 beam search 时，可以是每个词汇表标记的 log softmax。
  
• cur_len (int) — 有效输入序列标记的当前长度。在 TF 实现中，input_ids 的序列长度是生成器可以生成的最大长度，我们需要知道哪些标记是有效的。
  
• kwargs (Dict[str, Any]，可选) — 其他 logits 处理器特定的 kwargs。
  

返回

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

处理后的预测分数。

处理 logits 的 TF 方法。

class transformers.TFLogitsProcessorList

<来源>

( iterable = () )
• 1

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int **kwargs ) → export const metadata = 'undefined';tf.Tensor of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 获取索引。详情请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (tf.Tensor，形状为(batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时，这些可以是每个词汇表的 logits，或者在使用 beam search 时，可以是每个词汇表标记的 log softmax。
  
• cur_len (int) — 有效输入序列标记的当前长度。在 TF 实现中，input_ids 的序列长度是生成的最大长度，我们需要知道哪些标记是有效的。
  
• kwargs (Dict[str, Any], 可选) — 额外的 logits 处理器特定 kwargs。
  

返回

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

处理后的预测分数。

class transformers.TFLogitsWarper

< source >

( )
• 1

用于在多项式采样生成期间应用的所有 logits 扭曲的抽象基类。

__call__

< source >

( input_ids: Tensor scores: Tensor cur_len: int ) → export const metadata = 'undefined';tf.Tensor of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (tf.Tensor，形状为 (batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用波束搜索时，这些可以是每个词汇的 logits，或者在使用波束搜索时，可以是每个词汇标记的 log softmax。
  
• cur_len (int) — 有效输入序列标记的当前长度。在 TF 实现中，input_ids 的序列长度是生成的最大长度，我们需要知道哪些标记是有效的。
  
• kwargs (Dict[str, Any], 可选) — 额外的 logits 处理器特定 kwargs。
  

返回

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

处理后的预测分数。

用于扭曲 logits 的 TF 方法。

class transformers.TFMinLengthLogitsProcessor

< source >

( min_length: int eos_token_id: int )
• 1

参数

• min_length (int) — 将 eos_token_id 的分数设置为 -float("Inf") 的最小长度。
  
• eos_token_id (int) — 序列结束 标记的 id。
  

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

__call__

< source >

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFNoBadWordsLogitsProcessor

< source >

( bad_words_ids: List eos_token_id: int )
• 1

参数

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

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

__call__

< source >

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFNoRepeatNGramLogitsProcessor

<来源>

( ngram_size: int )
• 1

参数

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

TFLogitsProcessor 强制不重复 n-gram。参见Fairseq。

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFRepetitionPenaltyLogitsProcessor

<来源>

( penalty: float )
• 1

参数

• repetition_penalty (float) — 重复惩罚的参数。1.0 表示没有惩罚。更多细节请参阅这篇论文。

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFSuppressTokensAtBeginLogitsProcessor

<来源>

( begin_suppress_tokens begin_index )
• 1

TFSuppressTokensAtBeginLogitsProcessor 在generate函数开始生成时立即抑制一组标记。这应该确保在生成开始时不会抽样到由begin_suppress_tokens定义的标记。

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFSuppressTokensLogitsProcessor

<来源>

( suppress_tokens )
• 1

这个处理器可以用来抑制一组标记。处理器将把它们的对数概率设置为-inf，以便它们不被抽样。

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFTemperatureLogitsWarper

<来源>

( temperature: float )
• 1

参数

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

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFTopKLogitsWarper

<来源>

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

参数

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

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

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

class transformers.TFTopPLogitsWarper

<来源>

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

参数

• top_p (float) — 如果设置为<1，则仅保留概率相加大于top_p或更高的最可能标记集。
  
• filter_value (float, 可选, 默认为-inf) — 所有被过滤的值将被设置为这个浮点值。
  
• min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的最小标记数。
  

TFLogitsWarper 执行 top-p，即限制总和小于等于 prob_cut_off 的顶级标记。

__call__

<来源>

( input_ids: Tensor scores: Tensor cur_len: int )
• 1

FLAX

class transformers.FlaxForcedBOSTokenLogitsProcessor

<来源>

( bos_token_id: int )
• 1

参数

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

FlaxLogitsProcessor 将指定的标记作为第一个生成的标记。

__call__

<来源>

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxForcedEOSTokenLogitsProcessor

<来源>

( max_length: int eos_token_id: int )
• 1

参数

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

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

__call__

<来源>

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxForceTokensLogitsProcessor

<来源>

( force_token_map )
• 1

参数

• force_token_map (list) — 给出标记 id 和它们将被强制采样的索引的映射。

FlaxLogitsProcessor 接受一对整数的列表，指示从生成索引到标记索引的映射，这些标记将在采样之前被强制。处理器将它们的对数概率设置为 0，将所有其他标记设置为-inf，以便它们在相应的索引处被采样。

__call__

<来源>

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxLogitsProcessor

<来源>

( )
• 1

所有在生成期间可以应用的 logit 处理器的抽象基类。

__call__

<来源>

( input_ids: Array scores: Array ) → export const metadata = 'undefined';jnp.ndarray of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (jnp.ndarray，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (jnp.ndarray的形状为(batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时，这些可以是每个词汇的 logits，或者在使用 beam search 时，可以是每个词汇标记的 log softmax
  
• kwargs (Dict[str, Any], optional) — 特定于 logits 处理器的额外 kwargs。
  

返回

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

处理后的预测分数。

Flax 处理 logits 的方法。

class transformers.FlaxLogitsProcessorList

<来源>

( iterable = () )
• 1

此类可用于创建 FlaxLogitsProcessor 或 FlaxLogitsWarper 的列表，以随后处理scores输入张量。此类继承自列表，并添加了一个特定的call方法来应用每个 FlaxLogitsProcessor 或 FlaxLogitsWarper 到输入中。

__call__

<来源>

( input_ids: Array scores: Array cur_len: int **kwargs ) → export const metadata = 'undefined';jnp.ndarray of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (jnp.ndarray的形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (jnp.ndarray的形状为(batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时，这些可以是每个词汇的 logits，或者在使用 beam search 时，可以是每个词汇标记的 log softmax
  
• kwargs (Dict[str, Any], optional) — 特定于 logits 处理器的额外 kwargs。
  

返回

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

处理后的预测分数。

class transformers.FlaxLogitsWarper

<来源>

( )
• 1

用于在生成过程中应用多项式采样的所有 logit 扭曲器的抽象基类。

__call__

<来源>

( input_ids: Array scores: Array ) → export const metadata = 'undefined';jnp.ndarray of shape (batch_size, config.vocab_size)
• 1

参数

• input_ids (jnp.ndarray的形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 PreTrainedTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• scores (jnp.ndarray的形状为(batch_size, config.vocab_size)) — 语言建模头的预测分数。当不使用 beam search 时，这些可以是每个词汇的 logits，或者在使用 beam search 时，可以是每个词汇标记的 log softmax
  
• kwargs (Dict[str, Any], optional) — 特定于 logits 处理器的额外 kwargs。
  

返回

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

处理后的预测分数。

Flax 扭曲 logits 的方法。

class transformers.FlaxMinLengthLogitsProcessor

< source >

( min_length: int eos_token_id: int )
• 1

参数

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

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

__call__

< source >

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxSuppressTokensAtBeginLogitsProcessor

< source >

( begin_suppress_tokens begin_index )
• 1

参数

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

FlaxLogitsProcessor 在 generate 函数开始生成时立即抑制一组标记，使用 begin_index 标记。这应该确保由 begin_suppress_tokens 定义的标记在生成开始时不被采样。

__call__

< source >

( input_ids scores cur_len: int )
• 1

class transformers.FlaxSuppressTokensLogitsProcessor

< source >

( suppress_tokens: list )
• 1

参数

• suppress_tokens (list) — 不采样的标记。

FlaxLogitsProcessor 在每个解码步骤抑制一组标记。处理器将它们的对数概率设置为 -inf，以便它们不被采样。

__call__

< source >

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxTemperatureLogitsWarper

< source >

( temperature: float )
• 1

参数

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

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

__call__

< source >

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxTopKLogitsWarper

< source >

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

参数

• top_k (int) — 保留最高概率词汇标记的数量以进行 top-k 过滤。
  
• filter_value (float, 可选, 默认为 -inf) — 所有过滤值将被设置为此浮点值。
  
• min_tokens_to_keep (int, 可选, 默认为 1) — 不能被过滤的最小标记数。
  

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

__call__

< source >

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxTopPLogitsWarper

< source >

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

参数

• top_p (float) — 如果设置为 < 1，则只保留概率相加达到 top_p 或更高的最小一组最可能的标记用于生成。
  
• filter_value (float, 可选, 默认为 -inf) — 所有过滤值将被设置为此浮点值。
  
• min_tokens_to_keep (int，可选，默认为 1) — 不能被过滤的最小标记数。
  

FlaxLogitsWarper 执行 top-p，即限制总概率小于等于 prob_cut_off 的前 p 个标记。

__call__

< source >

( input_ids: Array scores: Array cur_len: int )
• 1

class transformers.FlaxWhisperTimeStampLogitsProcessor

< source >

( generate_config model_config decoder_input_length )
• 1

参数

• 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__

< source >

( input_ids scores cur_len )
• 1

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