Transformers 文档
CLVP
并获得增强的文档体验
开始使用
CLVP
概述
CLVP（对比语言-语音预训练 Transformer）模型由 James Betker 在通过缩放获得更好的语音合成中提出。
该论文的摘要如下：
近年来，图像生成领域因自回归 Transformer 和 DDPM 的应用而发生了革命性的变化。这些方法将图像生成过程建模为逐步概率过程，并利用大量的计算和数据来学习图像分布。这种提高性能的方法不应仅限于图像。本文介绍了一种将图像生成领域的进展应用于语音合成的方法。结果是 TorToise - 一种富有表现力的多语音文本到语音系统。
此模型由 Susnato Dhar 贡献。 原始代码可以在这里找到。
使用技巧
- CLVP 是 Tortoise TTS 模型不可或缺的一部分。
- CLVP 可用于将不同的生成的语音候选项与提供的文本进行比较，并将最佳的语音 tokens 转发到扩散模型。
- 强烈建议在 tortoise 中使用
ClvpModelForConditionalGeneration.generate()方法。 - 请注意，与其他期望 16 kHz 音频模型的音频模型相反，CLVP 模型期望音频以 22.05 kHz 的采样率进行采样。
简要说明：
- ClvpTokenizer 对文本输入进行分词，ClvpFeatureExtractor 从所需的音频中提取 log mel 频谱图。
ClvpConditioningEncoder接受这些文本 tokens 和音频表示，并将它们转换为以文本和音频为条件的嵌入。- ClvpForCausalLM 使用这些嵌入来生成多个语音候选项。
- 每个语音候选项都通过语音编码器 (ClvpEncoder) 传递，语音编码器将它们转换为向量表示，文本编码器 (ClvpEncoder) 将文本 tokens 转换为相同的潜在空间。
- 最后，我们将每个语音向量与文本向量进行比较，以查看哪个语音向量与文本向量最相似。
ClvpModelForConditionalGeneration.generate()将上述所有逻辑压缩到一个方法中。
示例
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration
>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> sample = ds[0]["audio"]
>>> # Define processor and model.
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")
>>> # Generate processor output and model output.
>>> processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt")
>>> generated_output = model.generate(**processor_output)ClvpConfig
class transformers.ClvpConfig
< source >( text_config = None speech_config = None decoder_config = None projection_dim = 768 logit_scale_init_value = 2.6592 initializer_factor = 1.0 **kwargs )
参数
- text_config (
dict, 可选) — 用于初始化 CLVP 文本编码器的配置选项字典。 - speech_config (
dict, 可选) — 用于初始化 CLVP 语音编码器的配置选项字典。 - decoder_config (
dict, 可选) — 用于初始化 ClvpDecoderConfig 的配置选项字典。 - projection_dim (
int, 可选, 默认为 768) — 文本和语音投影层的维度。 - logit_scale_init_value (
float, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值按照原始 CLVP 实现使用。 - initializer_factor (
float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1.0，在内部用于初始化测试）。 - kwargs (可选) — 关键字参数字典。
ClvpConfig 是用于存储 ClvpModelForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 CLVP 模型，定义文本模型、语音模型和解码器模型配置。使用默认值实例化配置将产生与 CLVP susnato/clvp_dev 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import ClvpConfig, ClvpModelForConditionalGeneration
>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()
>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig
>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()
>>> config = ClvpConfig.from_sub_model_configs(config_text, config_speech, decoder_config)from_sub_model_configs
< source >( text_config: ClvpEncoderConfig speech_config: ClvpEncoderConfig decoder_config: ClvpDecoderConfig **kwargs ) → ClvpConfig
参数
- text_config (
ClvpEncoderConfig) — 文本模型配置，类型为 ClvpEncoderConfig。 - speech_config (
ClvpEncoderConfig) — 语音模型配置，类型为 ClvpEncoderConfig。 - decoder_config (
ClvpDecoderConfig) — 解码器模型配置，类型为 ClvpDecoderConfig。
返回值
配置对象的实例
从 CLVP 文本模型配置、CLVP 语音模型配置和 CLVP 解码器模型配置实例化一个 ClvpConfig (或派生类)。
ClvpEncoderConfig
class transformers.ClvpEncoderConfig
< source >( vocab_size = 256 hidden_size = 768 intermediate_size = 1536 projection_dim = 768 num_hidden_layers = 20 num_attention_heads = 12 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.1 dropout = 0.1 use_rotary_embedding = True use_attention_bias = False summary_type = 'mean' initializer_factor = 1.0 bos_token_id = 255 eos_token_id = 0 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 256) — CLVP 编码器模型的词汇表大小。 - hidden_size (
int, 可选, 默认为 768) — 编码器层和池化层的维度。 - intermediate_size (
int, 可选, 默认为 1536) — Transformer 编码器中“中间”（即，前馈）层的维度。 - projection_dim (
int, 可选, 默认为 768) — 投影向量的维度。 - num_hidden_layers (
int, 可选, 默认为 20) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。 - hidden_act (
str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu","relu","selu","gelu_new"和"quick_gelu"。 - layer_norm_eps (
float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon 值。 - attention_dropout (
float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。 - dropout (
float, 可选, 默认为 0.1) —ClvpEncoderMLP中前馈层的 dropout 比率。 - use_rotary_embedding (
bool, 可选, 默认为True) — 是否使用 rotary_embedding。 - use_attention_bias (
bool, 可选, 默认为False) — 在自注意力期间是否在 Query、Key 和 Value 层中使用偏置。 - summary_type (
str, 可选, 默认为"mean") — 从 last_hidden_state 获取 pooler_output 使用的策略。 支持"last","first","mean"和"cls_index"。 - initializer_factor (
float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子 (应保持为 1.0，内部用于初始化测试)。 - bos_token_id (
int, 可选, 默认为 255) — 序列开始 token id。 - eos_token_id (
int, 可选, 默认为 0) — 序列结束 token id。
这是用于存储 ClvpEncoder 配置的配置类。 它用于根据指定的参数实例化 CLVP 文本或 CLVP 语音编码器。 使用默认值实例化配置将产生与 CLVP susnato/clvp_dev 架构的编码器类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import ClvpEncoderConfig, ClvpEncoder
>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()
>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)
>>> # Accessing the model configuration
>>> configuration = model.configClvpDecoderConfig
class transformers.ClvpDecoderConfig
< source >( vocab_size = 8194 max_position_embeddings = 608 max_text_tokens = 404 hidden_size = 1024 num_hidden_layers = 30 num_attention_heads = 16 n_inner = None num_mel_attn_blocks = 6 activation_function = 'gelu_new' resid_pdrop = 0.1 embd_pdrop = 0.1 attention_dropout = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 summary_type = 'cls_index' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 use_cache = True bos_token_id = 8192 eos_token_id = 8193 feature_size = 80 use_attention_bias = True initializer_factor = 1.0 decoder_fixing_codes = [83, 45, 45, 248] **kwargs )
参数
- vocab_size (
int, 可选, 默认为 8194) — 模型的词汇表大小。 - max_position_embeddings (
int, 可选, 默认为 608) — 模型可能使用的 mel 令牌的最大序列长度。类似于GPT2Config中的n_positions。 - max_text_tokens (
int, 可选, 默认为 404) — 模型可能使用的文本令牌的最大序列长度。类似于GPT2Config中的n_positions。 - hidden_size (
int, 可选, 默认为 1024) — 嵌入和隐藏状态的维度。 - num_hidden_layers (
int, 可选, 默认为 30) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - n_inner (
int, 可选) — 内部前馈层维度。None将会设置为hidden_size的 4 倍。 - num_mel_attn_blocks (
int, 可选, 默认为 6) — 表示ClvpConditioningEncoder中自注意力层的数量。 - activation_function (
str, 可选, 默认为"gelu_new") — 激活函数，从列表["relu", "silu", "gelu", "tanh", "gelu_new"]中选择。 - resid_pdrop (
float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - embd_pdrop (
float, 可选, 默认为 0.1) — 嵌入层的 dropout 比率。 - attention_dropout (
float, 可选, 默认为 0.1) — 注意力层的 dropout 比率。 - layer_norm_epsilon (
float, 可选, 默认为 1e-05) — 层归一化层中使用的 epsilon 值。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - summary_type (
string, 可选, 默认为"cls_index") — 进行序列摘要时使用的参数。必须是以下选项之一：
"last"：获取最后一个令牌的隐藏状态（如 XLNet）。"first"：获取第一个令牌的隐藏状态（如 BERT）。"mean"：获取所有令牌隐藏状态的均值。"cls_index"：提供分类令牌位置的张量（如 GPT/GPT-2）。"attn"：目前未实现，请使用多头注意力。
- summary_use_proj (
bool, 可选, 默认为True) — 是否在向量提取后添加一个投影层。 - summary_activation (
str, 可选) — 传递"tanh"以将 tanh 激活应用于输出，任何其他值将导致不进行激活。 - summary_proj_to_labels (
bool, 可选, 默认为True) — 投影输出是否应具有config.num_labels或config.hidden_size类。 - summary_first_dropout (
float, 可选, 默认为 0.1) — 在投影和激活之后使用的 dropout 比率。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。 - bos_token_id (
int, 可选, 默认为 8192) — 序列开始令牌 ID，在生成开始时使用。 - eos_token_id (
int, 可选, 默认为 8193) — 序列结束令牌 ID，在方法ClvpModelForConditionalGeneration.fix_speech_decoder_output()中用于修正解码器输出。 - feature_size (
int, 可选, 默认为 80) — 提取的 mel 特征的特征维度。此值在ClvpConditioningEncoder中使用。 - use_attention_bias (
bool, 可选, 默认为True) — 在自注意力期间是否在 Query、Key 和 Value 层中使用偏置。 - initializer_factor (
float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1.0，内部用于初始化测试）。 - decoder_fixing_codes (
list, 可选, 默认为[83, 45, 45, 248]) — 这些值在方法fix_speech_decoder_output中用于修正解码器生成的输出。
这是用于存储 ClvpDecoder 配置的配置类。它用于根据指定的参数实例化 CLVP 解码器模型，定义模型架构。使用默认值实例化配置将产生与 CLVP susnato/clvp_dev 架构的解码器部分类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
该架构类似于 GPT2。
示例
>>> from transformers import ClvpDecoderConfig, ClvpDecoder
>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()
>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)
>>> # Accessing the model configuration
>>> configuration = model.configClvpTokenizer
class transformers.ClvpTokenizer
< source >( vocab_file merges_file errors = 'replace' unk_token = '[UNK]' bos_token = '<|endoftext|>' eos_token = '[STOP]' pad_token = '[STOP]' add_prefix_space = False add_bos_token = False add_eos_token = False **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — merges 文件的路径。 - errors (
str, 可选, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范例。 有关更多信息，请参阅 bytes.decode。 - unk_token (
str, 可选, 默认为"[UNK]") — 未知 token。 词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。 - bos_token (
str, 可选, 默认为"<|endoftext|>") — 序列的起始 token。 - eos_token (
str, 可选, 默认为"[STOP]") — 序列的结束 token。 - pad_token (
str, 可选, 默认为"[STOP]") — 序列的 padding token。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入文本前添加一个初始空格。 这允许像对待任何其他单词一样对待句首单词。（CLVP tokenizer 通过前导空格检测单词的开头）。 - add_bos_token (
bool, 可选, 默认为False) — 当add_special_tokens=True时，是否在序列前面添加bos_token。 - add_eos_token (
bool, 可选, 默认为False) — 当add_special_tokens=True时，是否在序列末尾添加eos_token。
构建 CLVP tokenizer。 基于字节级 Byte-Pair-Encoding。
此 tokenizer 经过训练，将空格视为 token 的一部分（有点像 sentencepiece），因此一个单词
在句首（没有空格）或不在句首时，编码方式会有所不同。
>>> from transformers import ClvpTokenizer
>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]
>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]您可以通过在实例化此 tokenizer 或在某些文本上调用它时传递 add_prefix_space=True 来规避此行为，但由于模型并非以此方式预训练，因此可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此 tokenizer 将在每个单词（甚至是第一个单词）之前添加一个空格。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
ClvpFeatureExtractor
class transformers.ClvpFeatureExtractor
< source >( feature_size = 80 sampling_rate = 22050 default_audio_length = 6 hop_length = 256 chunk_length = 30 n_fft = 1024 padding_value = 0.0 mel_norms = None return_attention_mask = False **kwargs )
参数
- feature_size (
int, 可选, 默认为 80) — 提取特征的特征维度。 - sampling_rate (
int, 可选, 默认为 22050) — 音频文件应数字化的采样率，以赫兹 (Hz) 表示。 - default_audio_length (
int, 可选, 默认为 6) — 原始音频的默认长度，以秒为单位。 如果在__call__期间未设置max_length，则会自动将其设置为 default_audio_length *self.sampling_rate。 - hop_length (
int, 可选, 默认为 256) — 用于获得 Mel 频率系数的 STFT 的重叠窗口长度。 - chunk_length (
int, 可选, 默认为 30) — 用于修剪和填充较长或较短音频序列的最大sampling_rate样本块数。 - n_fft (
int, 可选, 默认为 1024) — 傅里叶变换的大小。 - padding_value (
float, 可选, 默认为 0.0) — 用于 padding 音频的 padding 值。 应对应于静音。 - mel_norms (长度为
feature_size的list, 可选) — 如果提供了mel_norms，则它将用于沿每个 mel 滤波器归一化 log-mel 频谱图。 - return_attention_mask (
bool, 可选, 默认为False) — 是否返回 attention mask。 如果保留为默认值，它将返回 attention mask。
构建 CLVP 特征提取器。
此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
此类使用自定义 numpy 实现的 短时傅里叶变换 从原始语音中提取 log-mel-spectrogram 特征，该实现应与 pytorch 的 torch.stft 等效项匹配。
__call__
< source >( raw_speech: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]]] sampling_rate: typing.Optional[int] = None truncation: bool = True pad_to_multiple_of: typing.Optional[int] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_attention_mask: typing.Optional[bool] = True padding: typing.Optional[str] = 'max_length' max_length: typing.Optional[int] = None **kwargs )
参数
- raw_speech (
np.ndarray,List[float],List[np.ndarray],List[List[float]]) — 要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。 必须是单声道音频，而非立体声，即每个时间步单个浮点值。 - sampling_rate (
int, 可选) —raw_speech输入被采样的采样率。 强烈建议在前向调用时传递sampling_rate以防止静默错误并允许自动语音识别流程。 - truncation (
bool, 可选, 默认为True) — 激活截断以将长于 max_length 的输入序列截断为 max_length。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充为提供值的倍数。这对于在计算能力
>= 7.5(Volta) 的 NVIDIA 硬件或在序列长度为 128 的倍数时受益的 TPU 上启用 Tensor Cores 的使用尤其有用。 - return_attention_mask (
bool, 可选, 默认为True) — 是否返回 attention mask。 如果保留为默认值，它将返回 attention mask。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- padding_value (
float, 可选, 默认为 0.0) — 用于填充 padding 值/向量的值。 - max_length (
int, 可选) — 输入的最大长度。
ClvpFeatureExtractor 用于从样本声音或 raw_speech 中提取各种特定于语音的属性，例如语音的音高和音调、语速，甚至语音缺陷（如口齿不清或口吃）。
首先，以某种方式填充或截断语音，使其成为 self.default_audio_length 秒长的波形，然后从中提取 log-mel 频谱图。
ClvpProcessor
class transformers.ClvpProcessor
< source >( feature_extractor tokenizer )
参数
- feature_extractor (
ClvpFeatureExtractor) — ClvpFeatureExtractor 的一个实例。 feature extractor 是必需的输入。 - tokenizer (
ClvpTokenizer) — ClvpTokenizer 的一个实例。 tokenizer 是必需的输入。
构建一个 CLVP processor，它将 CLVP Feature Extractor 和 CLVP Tokenizer 封装到单个 processor 中。
ClvpProcessor 提供了 ClvpFeatureExtractor 和 ClvpTokenizer 的所有功能。 有关更多信息，请参阅 call(), decode() 和 batch_decode() 的文档。
此方法将其所有参数转发到 ClvpTokenizer 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 ClvpTokenizer 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
ClvpModelForConditionalGeneration
class transformers.ClvpModelForConditionalGeneration
< source >( config: ClvpConfig )
参数
- config (ClvpConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
复合 CLVP 模型，包含文本编码器、语音编码器和语音解码器模型。语音解码器模型从文本生成 speech_ids，文本编码器和语音编码器协同工作以筛选出最佳 speech_ids。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None input_features: FloatTensor = None conditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None text_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = False return_dict: typing.Optional[bool] = None ) → transformers.models.clvp.modeling_clvp.ClvpOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 词汇表中输入序列 tokens 的索引。 如果您提供 padding，默认情况下将忽略 padding。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- input_features (形状为
(batch_size, feature_size, time_dim)的torch.FloatTensor) — 指示由 ClvpFeatureExtractor 返回的音频的 log mel 频谱图表示。 - conditioning_encoder_inputs_embeds (
torch.FloatTensor, 可选) —ClvpConditioningEncoder的 inputs_embeds。 可以代替input_ids使用。 - text_encoder_inputs_embeds (
torch.FloatTensor, 可选) — 文本编码器模型的 inputs_embeds，用于代替input_ids传递。 - attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — Mask，用于避免对 padding 文本 token 索引执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 已被 mask 的 tokens。
- return_loss (
bool, optional) — 是否返回对比损失。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.models.clvp.modeling_clvp.ClvpOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clvp.modeling_clvp.ClvpOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.clvp.configuration_clvp.ClvpConfig'>) 和输入。
- loss (
torch.FloatTensor，形状为(1,)，可选，当return_loss为True时返回) — 用于语音-文本相似度的对比损失。 - speech_ids (
torch.LongTensor, optional) — 由ClvpForCausalLM模型生成的 speech_ids（或语音候选项）。 - logits_per_speech (
torch.FloatTensor，形状为(speech_batch_size, text_batch_size)) —speech_embeds和text_embeds之间缩放的点积分数。 这表示语音-文本相似度分数。 - logits_per_text (
torch.FloatTensor，形状为(text_batch_size, speech_batch_size)) —text_embeds和speech_embeds之间缩放的点积分数。 这表示文本-语音相似度分数。 - text_embeds (
torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于文本编码器模型的池化输出来获得的文本嵌入。 - speech_embeds (
torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于语音编码器模型的池化输出来获得的语音嵌入。 - text_model_output (
BaseModelOutputWithPooling) — 文本编码器模型的last_hidden_state的池化输出。 - speech_model_output (
BaseModelOutputWithPooling) — 语音编码器模型的last_hidden_state的池化输出。 - decoder_hidden_states (
torch.FloatTensor, optional) — 解码器模型的隐藏状态。 - text_encoder_hidden_states (
torch.FloatTensor, optional) — 文本编码器模型的隐藏状态。 - speech_encoder_hidden_states (
torch.FloatTensor, optional) — 语音编码器模型的隐藏状态。
ClvpModelForConditionalGeneration forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration
>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> _, audio, sr = ds.sort("id").select(range(1))[:1]["audio"][0].values()
>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")
>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
... input_ids=processor_output["input_ids"],
... input_features=processor_output["input_features"],
... return_dict=True,
... )generate
< source >( input_ids: LongTensor = None input_features: FloatTensor = None attention_mask: typing.Optional[torch.LongTensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None pad_to_max_mel_tokens: typing.Optional[int] = None output_hidden_states: typing.Optional[bool] = None **kwargs ) → ClvpOutput 或 tuple
参数
- input_ids (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 输入文本 Tokens。 从 ClvpTokenizer 处理而来。 - input_features (
torch.FloatTensor，形状为(batch_size, feature_size, time_dim)，可选) — 表示由 ClvpFeatureExtractor 返回的音频的 log-梅尔频谱图表示。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充文本标记索引上执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示未被掩蔽的标记，
- 0 表示被掩蔽的标记。
- generation_config (
~generation.GenerationConfig, optional) — 用作生成调用的基本参数化的生成配置。 传递给 generate 的**kwargs匹配generation_config的属性将覆盖它们。 如果未提供generation_config，将使用默认值，默认值具有以下加载优先级：1) 来自generation_config.json模型文件（如果存在）； 2) 来自模型配置。 请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。 - pad_to_max_mel_tokens (
int, optional) — 将生成的 speech_ids 填充到指定值。 这是为了实现来自官方 repo 的相同逻辑，链接： https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 并确保 logits 相同。 这不会影响生成质量，因此请不要考虑使用它，因为它效率较低。 - output_hidden_states (
bool, optional) — 是否返回解码器模型、文本编码器和语音编码器模型的隐藏状态。
返回值
ClvpOutput 或 tuple
一个 ClvpOutput （如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时）或一个元组。
ClvpModelForConditionalGeneration 的 Generate 方法，此方法调用 ClvpForCausalLM 的 generate 方法，然后使用那些生成的 speech_ids，通过 ClvpEncoder 处理 text_embeds 和 speech_embeds。
get_text_features
< source >( input_ids: typing.Optional[torch.LongTensor] = None text_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None ) → torch.FloatTensor，形状为 (batch_size, output_dim)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 如果您提供填充，默认情况下将忽略填充。 - text_encoder_inputs_embeds (
torch.FloatTensor, optional) — 用于文本编码器模型的 inputs_embeds，代替input_ids传递。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示未被掩蔽的标记，
- 0 表示被掩蔽的标记。
返回值
torch.FloatTensor，形状为 (batch_size, output_dim)
通过将投影层应用于 CLVP 文本模型的池化输出而获得的文本嵌入。
此方法可用于从文本中提取 text_embeds。 通过将投影层应用于 CLVP 文本编码器模型的池化输出而获得的文本嵌入。
示例
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration
>>> # Define the Text
>>> text = "This is an example text."
>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")
>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])get_speech_features
< source >( speech_ids: typing.Optional[torch.LongTensor] = None input_ids: typing.Optional[torch.LongTensor] = None input_features: typing.Optional[torch.FloatTensor] = None conditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None **kwargs ) → torch.FloatTensor，形状为 (batch_size, output_dim)
参数
- speech_ids (
torch.LongTensor，形状为(batch_size, num_speech_ids)，可选) — 语音 Tokens。 如果您提供填充，默认情况下将忽略填充。 如果提供了 speech_ids，则会自动忽略 input_ids 和 input_features。 - input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 输入文本 Tokens。 从 ClvpTokenizer 处理而来。 如果未提供 speech_ids，则将使用 input_ids 和 input_features。 - input_features (
torch.FloatTensor，形状为(batch_size, feature_size, time_dim)，可选) — 表示由 ClvpFeatureExtractor 返回的音频的 log-梅尔频谱图表示。 如果未提供 speech_ids，则将使用 input_ids 和 input_features。 - conditioning_encoder_inputs_embeds (
torch.FloatTensor, optional) —ClvpConditioningEncoder的 inputs_embeds。 可以代替input_ids使用。 - attention_mask (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充语音标记索引上执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示未被掩蔽的标记，
- 0 表示被掩蔽的标记。
- generation_config (
GenerationConfig, optional) — 用于控制 speech_ids 生成的生成配置（如果未提供）。
返回值
torch.FloatTensor，形状为 (batch_size, output_dim)
通过将投影层应用于 CLVP 语音模型的池化输出而获得的语音嵌入。
此方法可用于提取 speech_embeds。 语音嵌入是通过对 speech_ids 应用语音模型获得的。 如果 speech_ids 不存在，但同时给出了 input_ids 和 input_features，则将首先使用解码器模型生成 speech_ids，然后再应用语音模型。
示例
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration
>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> _, audio, sr = ds.sort("id").select(range(1))[:1]["audio"][0].values()
>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")
>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
... input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )ClvpForCausalLM
类 transformers.ClvpForCausalLM
< source >( config )
参数
- config (ClvpConfig) — 模型的配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
CLVP 解码器模型，顶部带有语言建模头。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- past_key_values (长度为
config.n_layers的Tuple[Tuple[torch.Tensor]]) — 包含模型计算的预计算隐藏状态（注意力模块中的键和值）（请参阅下面的past_key_values输出）。 可用于加速顺序解码。 已将过去状态提供给此模型的input_ids不应作为input_ids传递，因为它们已被计算。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行注意力的掩码。在[0, 1]中选择的掩码值：- 未掩码的 tokens 为 1，
- 已掩码的 tokens 为 0。
如果使用
past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids) - token_type_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。在[0, 1]中选择索引：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使 self-attention 模块的选定 head 无效的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。如果使用
past_key_values，则可以选择仅输入最后一个inputs_embeds（请参阅past_key_values）。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯元组。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于语言建模的标签。 请注意，标签在模型内部是移位的，即您可以设置labels = input_ids。 在[-100, 0, ..., config.vocab_size]中选择索引。 所有设置为-100的标签都将被忽略（掩码），损失仅针对[0, ..., config.vocab_size]中的标签计算。
ClvpForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
ClvpModel
类 transformers.ClvpModel
< source >( config: ClvpDecoderConfig )
参数
- config (ClvpConfig) — 模型的配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
裸 CLVP 解码器模型，输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- past_key_values (
Tuple[Tuple[torch.Tensor]]，长度为config.n_layers) — 包含模型计算出的预计算隐藏状态（attention 模块中的 key 和 values）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已将 past 提供给此模型的input_ids不应作为input_ids传递，因为它们已被计算过。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 Mask，
- 0 表示 tokens 已被 Mask。
如果使用
past_key_values，则attention_mask需要包含用于past_key_values的 Mask 策略。换句话说，attention_mask始终必须具有以下长度：len(past_key_values) + len(input_ids) - token_type_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — Segment token indices 以指示输入的第一部分和第二部分。 索引在[0, 1]中选择：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 tokens 在 position embeddings 中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 head 未被 Mask，
- 0 表示 head 已被 Mask。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部 embedding lookup matrix 更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。如果使用
past_key_values，则可以选择仅输入最后一个inputs_embeds（请参阅past_key_values）。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯 tuple。
ClvpModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
ClvpEncoder
Transformer 编码器，由 config.num_hidden_layers 个 self attention 层组成。 每个层都是一个 ClvpEncoderLayer。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型的输入 embeddings。 这会绕过模型的内部 embedding lookup matrix。 - attention_mask (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 Mask，
- 0 表示 tokens 已被 Mask。
- position_ids (
torch.LongTensor，可选) — 表示input_ids的位置 IDs。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯 tuple。
ClvpDecoder
Transformer 解码器，由 config.num_hidden_layers 层组成。 每个层都是一个 ClvpDecoderLayer
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- past_key_values (
Tuple[Tuple[torch.Tensor]]，长度为config.n_layers) — 包含模型计算出的预计算隐藏状态（attention 模块中的 key 和 values）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已将 past 提供给此模型的input_ids不应作为input_ids传递，因为它们已被计算过。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 Mask，
- 0 表示 tokens 已被 Mask。
如果使用
past_key_values，则attention_mask需要包含用于past_key_values的 Mask 策略。换句话说，attention_mask始终必须具有以下长度：len(past_key_values) + len(input_ids) - token_type_ids (
torch.LongTensor，形状为(batch_size, input_ids_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify 自注意力模块中选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 Mask，
- 0 表示 head 被 Mask。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。如果使用了
past_key_values，则可以选择仅输入最后的inputs_embeds（参见past_key_values）。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
ClvpDecoder forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。