Transformers

( 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

( text_config: ClvpEncoderConfig speech_config: ClvpEncoderConfig decoder_config: ClvpDecoderConfig **kwargs ) → ClvpConfig

参数

text_config (ClvpEncoderConfig) — 类型为 ClvpEncoderConfig 的文本模型配置。
speech_config (ClvpEncoderConfig) — 类型为 ClvpEncoderConfig 的语音模型配置。
decoder_config (ClvpDecoderConfig) — 类型为 ClvpDecoderConfig 的解码器模型配置。

ClvpConfig

一个配置对象的实例

从 CLVP 文本模型配置、CLVP 语音模型配置和 CLVP 解码器模型配置实例化一个 ClvpConfig (或其派生类)。

ClvpEncoderConfig

class transformers.ClvpEncoderConfig

( 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) — 是否使用旋转嵌入。
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) — 序列开始标记 ID。
eos_token_id (int, 可选, 默认为 0) — 序列结束标记 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.config

ClvpDecoderConfig

class transformers.ClvpDecoderConfig

( 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 tokens）的最大序列长度。类似于 GPT2Config 中的 n_positions。
max_text_tokens (int, 可选, 默认为 404) — 该模型可能使用的文本标记（text tokens）的最大序列长度。类似于 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) — 在嵌入层、编码器和池化层中所有全连接层的丢弃概率。
embd_pdrop (float, 可选, 默认为 0.1) — 嵌入层的丢弃率。
attention_dropout (float, 可选, 默认为 0.1) — 注意力层的丢弃率。
layer_norm_epsilon (float, 可选, 默认为 1e-05) — 在层归一化层中使用的 epsilon 值。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
summary_type (string, 可选, 默认为 "cls_index") — 进行序列摘要时使用的参数。

必须是以下选项之一：
- "last": 取最后一个词元（token）的隐藏状态（类似 XLNet）。
- "first": 取第一个词元（token）的隐藏状态（类似 BERT）。
- "mean": 取所有词元（token）隐藏状态的平均值。
- "cls_index": 提供一个分类词元（token）位置的张量（类似 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) — 在投影和激活之后使用的丢弃率。
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) — 提取的梅尔特征的特征维度。此值在 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.config

ClvpTokenizer

class transformers.ClvpTokenizer

( 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) — 合并文件的路径。
errors (str, 可选, 默认为 "replace") — 将字节解码为 UTF-8 时遵循的范式。更多信息请参见 bytes.decode。
unk_token (str, 可选, 默认为 "[UNK]") — 未知词元。不在词汇表中的词元无法转换为 ID，将被设置为此词元。
bos_token (str, 可选, 默认为 "<|endoftext|>") — 序列开始词元。
eos_token (str, 可选, 默认为 "[STOP]") — 序列结束词元。
pad_token (str, 可选, 默认为 "[STOP]") — 序列的填充词元。
add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这允许将首个单词像其他单词一样处理。（CLVP分词器通过前导空格来检测单词的开头）。
add_bos_token (bool, 可选, 默认为 False) — 当 add_special_tokens=True 时，是否在序列前添加 bos_token。
add_eos_token (bool, 可选, 默认为 False) — 当 add_special_tokens=True 时，是否在序列末尾添加 eos_token。

构建一个 CLVP 分词器。基于字节级的字节对编码（Byte-Pair-Encoding）。

这个分词器经过训练，将空格视为词元的一部分（有点像 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]

您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型并非以这种方式进行预训练，这可能会导致性能下降。

当与 is_split_into_words=True 一起使用时，此分词器会在每个词（甚至是第一个词）之前添加一个空格。

该分词器继承自 PreTrainedTokenizer，其中包含了大部分主要方法。用户应参考该超类以获取有关这些方法的更多信息。

save_vocabulary

( save_directory: str filename_prefix: typing.Optional[str] = None )

ClvpFeatureExtractor

class transformers.ClvpFeatureExtractor

( 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) — 用于获取梅尔频率系数的短时傅里叶变换（STFT）的重叠窗口长度。
chunk_length (int, 可选, 默认为 30) — 用于修剪和填充较长或较短音频序列的 sampling_rate 样本块的最大数量。
n_fft (int, 可选, 默认为 1024) — 傅里叶变换的大小。
padding_value (float, 可选, 默认为 0.0) — 用于填充音频的填充值。应对应于静音。
mel_norms (长度为 feature_size 的 list, 可选) — 如果提供了 mel_norms，它将被用来沿每个梅尔滤波器对对数梅尔谱图进行归一化。
return_attention_mask (bool, 可选, 默认为 False) — 是否返回注意力掩码。如果保留默认值，则会返回注意力掩码。

什么是注意力掩码？

构建一个 CLVP 特征提取器。

该特征提取器继承自 SequenceFeatureExtractor，其中包含了大部分主要方法。用户应参考该超类以获取有关这些方法的更多信息。

此类使用 短时傅里叶变换 的自定义 numpy 实现从原始语音中提取对数梅尔谱图特征，该实现应与 PyTorch 的 torch.stft 等效。

call

( raw_speech: typing.Union[numpy.ndarray, list[float], list[numpy.ndarray], list[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, optional) — 对 raw_speech 输入进行采样时的采样率。强烈建议在前向调用时传递 sampling_rate，以防止静默错误并启用自动语音识别管线。
truncation (bool, optional, 默认为 True) — 激活截断功能，将长于 max_length 的输入序列截断为 max_length。
pad_to_multiple_of (int, optional) — 如果设置，将序列填充到所提供值的倍数。

这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上使用 Tensor Cores，或在需要序列长度为 128 的倍数的 TPU 上特别有用。
return_attention_mask (bool, optional, 默认为 True) — 是否返回注意力掩码。如果保留为默认值，则会返回注意力掩码。

什么是注意力掩码？
return_tensors (str 或 TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf': 返回 TensorFlow tf.constant 对象。
- 'pt': 返回 PyTorch torch.Tensor 对象。
- 'np': 返回 Numpy np.ndarray 对象。
padding_value (float, optional, 默认为 0.0) — 用于填充填充值/向量的值。
max_length (int, optional) — 输入的最大输入长度。

ClvpFeatureExtractor 用于从样本语音或 raw_speech 中提取各种语音特定属性，如音高、音调、语速，甚至像口齿不清或口吃等语言缺陷。

首先，语音被填充或截断，使其成为一个长度为 self.default_audio_length 秒的波形，然后从中提取对数-梅尔频谱图。

ClvpProcessor

class transformers.ClvpProcessor

( feature_extractor tokenizer )

参数

feature_extractor (ClvpFeatureExtractor) — ClvpFeatureExtractor 的一个实例。特征提取器是必需的输入。
tokenizer (ClvpTokenizer) — ClvpTokenizer 的一个实例。分词器是必需的输入。

构建一个 CLVP 处理器，它将 CLVP 特征提取器和 CLVP 分词器包装成一个单一的处理器。

ClvpProcessor 提供了 ClvpFeatureExtractor 和 ClvpTokenizer 的所有功能。请参阅 call()、decode() 和 batch_decode() 了解更多信息。

call

( *args **kwargs )

将 audio 和 sampling_rate 参数转发给 call()，并将 text 参数转发给 call()。请参考上述两种方法的文档字符串以获取更多信息。

decode

( *args **kwargs )

此方法将其所有参数转发给 ClvpTokenizer 的 decode() 方法。请参考此方法的文档字符串以获取更多信息。

batch_decode

( *args **kwargs )

此方法将其所有参数转发给 ClvpTokenizer 的 batch_decode() 方法。请参考此方法的文档字符串以获取更多信息。

ClvpModelForConditionalGeneration

class transformers.ClvpModelForConditionalGeneration

( config: ClvpConfig )

参数

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

包含文本编码器、语音编码器和语音解码器模型的复合 CLVP 模型。

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

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

( input_ids: typing.Optional[torch.LongTensor] = None input_features: typing.Optional[torch.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 (torch.LongTensor, 形状为 (batch_size, sequence_length), optional) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
input_features (torch.FloatTensor, 形状为 (batch_size, feature_size, time_dim)) — 表示由 ClvpFeatureExtractor 返回的音频的对数-梅尔频谱图表示。
conditioning_encoder_inputs_embeds (torch.FloatTensor, optional) — ClvpConditioningEncoder 的 inputs_embeds。可替代 input_ids 使用。
text_encoder_inputs_embeds (torch.FloatTensor, optional) — 传递给文本编码器模型的 inputs_embeds，以代替 input_ids。
attention_mask (torch.LongTensor, 形状为 (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
什么是注意力掩码？
return_loss (bool, optional) — 是否返回对比损失。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量下的 hidden_states。
output_attentions (bool, optional, 默认为 False) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量下的 attentions。
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 时），根据配置（ClvpConfig）和输入，包含各种元素。

loss (torch.FloatTensor, 形状为 (1,), optional, 当 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 (<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output, 默认为 None) — 文本编码器模型的 last_hidden_state 的池化输出。
speech_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.speech_model_output, 默认为 None) — 语音编码器模型的 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,
... )

生成

( input_ids: typing.Optional[torch.LongTensor] = None input_features: typing.Optional[torch.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 或元组

参数

input_ids (torch.FloatTensor, 形状为 (batch_size, sequence_length), optional) — 输入文本标记。由 ClvpTokenizer 处理。
input_features (torch.FloatTensor, 形状为 (batch_size, feature_size, time_dim), optional) — 表示由 ClvpFeatureExtractor 返回的音频的对数-梅尔频谱图表示。
attention_mask (torch.Tensor, 形状为 (batch_size, sequence_length), optional) — 用于避免在填充文本标记索引上执行注意力操作的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
什么是注意力掩码？
generation_config (~generation.GenerationConfig, optional) — 用于生成调用的基础参数化的生成配置。传递给 generate 的与 generation_config 属性匹配的 **kwargs 将覆盖它们。如果未提供 generation_config，将使用默认值，其加载优先级如下：1) 从 generation_config.json 模型文件（如果存在）；2) 从模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。
pad_to_max_mel_tokens (int, optional) — 将生成的 speech_ids 填充到指定值。这是为了实现官方仓库中的相同逻辑，链接：https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 并确保 logits 相同。这不影响生成质量，因此请不要考虑使用它，因为它效率较低。
output_hidden_states (bool, optional) — 是否返回解码器模型、文本编码器和语音编码器模型的隐藏状态。

ClvpOutput 或元组

一个 ClvpOutput（如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时）或一个元组。

ClvpModelForConditionalGeneration 的生成方法，此方法调用 ClvpForCausalLM 的 generate 方法，然后使用生成的 speech_ids 通过 ClvpEncoder 处理 text_embeds 和 speech_embeds。

get_text_features

( 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)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将被忽略。

什么是输入 ID？
text_encoder_inputs_embeds (torch.FloatTensor, optional) — 传递给文本编码器模型的 inputs_embeds，以代替 input_ids。
attention_mask (torch.Tensor, 形状为 (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值在 [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

( 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), optional) — 语音标记。如果您提供填充，默认情况下将被忽略。如果提供了 speech_ids，则 input_ids 和 input_features 将被自动忽略。
input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), optional) — 输入文本标记。由 ClvpTokenizer 处理。如果未提供 speech_ids，则将使用 input_ids 和 input_features。
input_features (torch.FloatTensor，形状为 (batch_size, feature_size, time_dim)，可选) — 表示由 ClvpFeatureExtractor 返回的音频的 log-melspectrogram 表示。如果未提供 speech_ids，则将使用 input_ids 和 input_features。
conditioning_encoder_inputs_embeds (torch.FloatTensor, 可选) — ClvpConditioningEncoder 的 inputs_embeds。可以用来替代 input_ids。
attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充的语音标记索引上执行注意力机制的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
什么是注意力掩码？
generation_config (GenerationConfig, 可选) — 用于控制 speech_ids 生成的配置，如果未提供 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

class transformers.ClvpForCausalLM

( config )

参数

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

带有语言模型头的 CLVP 解码器模型。

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

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[tuple[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 ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速顺序解码。这通常包括在解码的先前阶段，当 use_cache=True 或 config.use_cache=True 时由模型返回的 past_key_values。

允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果未传递 past_key_values，则将返回传统缓存格式。

如果使用 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有为其提供过去键值状态的 ID），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充的标记索引上执行注意力机制的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引的选择范围为 [0, 1]：
- 0 对应于 *A 句* 标记，
- 1 对应于 *B 句* 标记。
什么是标记类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头无效的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示头未被掩码，
- 0 表示头已被掩码。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 语言建模的标签。请注意，标签在模型内部已移位，即您可以设置 labels = input_ids。索引选择范围为 [-100, 0, ..., config.vocab_size]。所有设置为 -100 的标签都会被忽略（掩码），损失仅针对 [0, ..., config.vocab_size] 中的标签计算。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (ClvpConfig) 和输入包含各种元素。

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), 可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则一个为嵌入的输出，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。
past_key_values (Cache, 可选，在传递 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

ClvpForCausalLM 的前向方法，覆盖了 __call__ 特殊方法。

ClvpModel

class transformers.ClvpModel

( config: ClvpDecoderConfig )

参数

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

裸 Clvp 模型，输出原始隐藏状态，顶部没有任何特定的头。

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

该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

( 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[tuple[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 ) → transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充的标记索引上执行注意力机制的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引的选择范围为 [0, 1]：
- 0 对应于 *A 句* 标记，
- 1 对应于 *B 句* 标记。
什么是标记类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头无效的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示头未被掩码，
- 0 表示头已被掩码。
past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速顺序解码。这通常包括在解码的先前阶段，当 use_cache=True 或 config.use_cache=True 时由模型返回的 past_key_values。

允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果未传递 past_key_values，则将返回传统缓存格式。

如果使用 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有为其提供过去键值状态的 ID），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (ClvpConfig) 和输入包含各种元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (Cache, 可选，在传递 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预先计算的隐藏状态（自注意块中的键和值，如果 config.is_encoder_decoder=True，则还包括交叉注意块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), 可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则一个为嵌入的输出，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选，在传递 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

ClvpModel 的前向方法，覆盖了 __call__ 特殊方法。

ClvpEncoder

class transformers.ClvpEncoder

( config: ClvpConfig )

参数

config — ClvpConfig

由 config.num_hidden_layers 个自注意力层组成的 Transformer 编码器。每个层都是一个 ClvpEncoderLayer。

forward

( 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)，可选) — 词汇表中输入序列标记的索引。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型的输入嵌入。这会绕过模型的内部嵌入查找矩阵。
attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充的标记索引上执行注意力机制的掩码。掩码值的选择范围为 [0, 1]：
- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
什么是注意力掩码？
position_ids (torch.LongTensor, 可选) — 表示 input_ids 的位置 ID。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

ClvpDecoder

class transformers.ClvpDecoder

( config )

Transformer 解码器由 *config.num_hidden_layers* 层组成。每一层都是一个 ClvpDecoderLayer

forward