Transformers documentation
CLVP
该模型于 2023-05-12 在 HF papers 上发布，并于 2023-11-10 贡献至 Hugging Face Transformers。
CLVP
概述
CLVP（Contrastive Language-Voice Pretrained Transformer）模型由 James Betker 在 Better speech synthesis through scaling 中提出。
该论文的摘要如下：
近年来，自回归 Transformer 和 DDPM 的应用彻底改变了图像生成领域。这些方法将图像生成过程建模为逐步的概率过程，并利用大量的计算资源和数据来学习图像分布。这种提升性能的方法并不局限于图像领域。本文介绍了一种将图像生成领域的最新进展应用于语音合成的方法。其成果是 TorToise——一个富有表现力、支持多音色的文本转语音系统。
该模型由 Susnato Dhar 贡献。 原始代码可在此处找到。
使用技巧
- CLVP 是 Tortoise TTS 模型的重要组成部分。
- CLVP 可用于将不同的生成语音候选项与提供的文本进行比较，并将最佳的语音 token 传递给扩散模型。
- 强烈建议使用
ClvpModelForConditionalGeneration.generate()方法来使用 tortoise。 - 请注意，与其他期望 16 kHz 采样率的音频模型不同，CLVP 模型期望音频以 22.05 kHz 进行采样。
简要说明
- ClvpTokenizer 对文本输入进行分词，ClvpFeatureExtractor 从目标音频中提取对数梅尔频谱图。
ClvpConditioningEncoder接收这些文本 token 和音频表示，并将其转换为基于文本和音频条件的嵌入。- ClvpForCausalLM 使用这些嵌入来生成多个语音候选项。
- 每个语音候选项都会通过语音编码器（ClvpEncoder）进行处理，将其转换为向量表示；文本编码器（ClvpEncoder）则将文本标记转换到相同的潜在空间中。
- 最后，我们将每个语音向量与文本向量进行比较，以查看哪个语音向量与文本向量最为相似。
ClvpModelForConditionalGeneration.generate()将上述所有逻辑压缩到一个方法中。
示例：
import datasets
from transformers import ClvpModelForConditionalGeneration, ClvpProcessor
# 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", device_map="auto")
# Generate processor output and model output.
processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt").to(model.device)
generated_output = model.generate(**processor_output)ClvpConfig
class transformers.ClvpConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonespeech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojection_dim: int = 768logit_scale_init_value: float = 2.6592initializer_factor: float = 1.0 )
参数
- text_config (
Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 文本骨干网络的配置对象或字典。 - speech_config (
dict, 可选) — 用于初始化 CLVP 语音编码器的配置选项字典。 - decoder_config (
dict, 可选) — 用于初始化 ClvpDecoderConfig 的配置选项字典。 - projection_dim (
int，可选，默认为768) — 文本和视觉投影层的维度。 - logit_scale_init_value (
float，可选，默认为2.6592) — logit_scale 参数的初始值。 - initializer_factor (
float，可选，默认为1.0) — 用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。
这是用于存储 ClvpModelForConditionalGeneration 配置的类。它根据指定的参数实例化 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(config_text, config_speech, decoder_config)ClvpEncoderConfig
class transformers.ClvpEncoderConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 256hidden_size: int = 768intermediate_size: int = 1536projection_dim: int = 768num_hidden_layers: int = 20num_attention_heads: int = 12hidden_act: str = 'gelu'layer_norm_eps: float = 1e-05attention_dropout: float | int = 0.1dropout: float | int = 0.1use_rotary_embedding: bool = Trueuse_attention_bias: bool = Falsesummary_type: str = 'mean'initializer_factor: float = 1.0bos_token_id: int | None = 255eos_token_id: int | list[int] | None = 0pad_token_id: int | None = None )
参数
- vocab_size (
int，可选，默认为256) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - hidden_size (
int，可选，默认为768) — 隐藏表示的维度。 - intermediate_size (
int，可选，默认为1536) — MLP 表示的维度。 - projection_dim (
int，可选，默认为768) — 文本和视觉投影层的维度。 - num_hidden_layers (
int, 可选, 默认为20) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int，可选，默认为12) — Transformer 解码器中每个注意力层的注意力头数量。 - hidden_act (
str，可选，默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - layer_norm_eps (
float，可选，默认为1e-05) — 层归一化层所使用的 epsilon 值。 - attention_dropout (
Union[float, int]，可选，默认为0.1) — 注意力概率的 dropout 比率。 - dropout (
Union[float, int]，可选，默认为0.1) — 所有 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，内部用于初始化测试）。 - bos_token_id (
int，可选，默认为255) — 词汇表中用于表示流起始的 Token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为0) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - pad_token_id (
int, 可选) — 词表中用于填充的 token id。
这是用于存储 ClvpModelForConditionalGeneration 配置的类。它根据指定的参数实例化 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 >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 8194max_position_embeddings: int = 608max_text_tokens: int = 404hidden_size: int = 1024num_hidden_layers: int = 30num_attention_heads: int = 16n_inner: int | None = Nonenum_mel_attn_blocks: int = 6activation_function: str = 'gelu_new'resid_pdrop: float | int = 0.1embd_pdrop: float | int = 0.1attention_dropout: float | int = 0.1layer_norm_epsilon: float = 1e-05initializer_range: float = 0.02summary_type: str = 'cls_index'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1use_cache: bool = Truebos_token_id: int | None = 8192eos_token_id: int | list[int] | None = 8193pad_token_id: int | None = Nonefeature_size: int = 80use_attention_bias: bool = Trueinitializer_factor: float = 1.0decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248)add_cross_attention: bool = False )
参数
- vocab_size (
int，可选，默认为8194) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - max_position_embeddings (
int，可选，默认为608) — 该模型可能使用的最大序列长度。 - max_text_tokens（
int，可选，默认值为 404）—— 该模型可能使用的文本 token 的最大序列长度。类似于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) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - resid_pdrop (
Union[float, int]，可选，默认为0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - embd_pdrop (
Union[float, int]，可选，默认为0.1) — 嵌入层的 dropout 比率。 - attention_dropout (
Union[float, int]，可选，默认为0.1) — 注意力概率的 dropout 比率。 - 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"：提供一个张量，指定分类标记的位置（类似于 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) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True或模型为仅解码器生成式模型时相关。 - bos_token_id (
int，可选，默认为8192) — 词汇表中用于表示流起始的 Token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为8193) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - pad_token_id (
int, 可选) — 词表中用于填充的 token id。 - feature_size (
int，可选，默认为 80) — 提取的 mel 特征的维度。该值用于ClvpConditioningEncoder。 - use_attention_bias (
bool，可选，默认为True) — 在自注意力机制中，是否在 Query、Key 和 Value 层中使用偏置。 - initializer_factor (
float，可选，默认为1.0) — 用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。 - decoder_fixing_codes（
list，可选，默认为[83, 45, 45, 248]）— 这些值用于fix_speech_decoder_output方法中，以修正解码器生成的输出。 - add_cross_attention (
bool，可选，默认为False) — 是否应在模型中添加交叉注意力层。
这是用于存储 ClvpModelForConditionalGeneration 配置的类。它根据指定的参数实例化 Clvp 模型，并定义模型架构。使用默认值实例化配置将得到与 susnato/clvp_dev 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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_filemerges_fileerrors = 'replace'unk_token = '[UNK]'bos_token = '<|endoftext|>'eos_token = '[STOP]'pad_token = '[STOP]'add_prefix_space = 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 分词器通过前导空格来检测单词的开头）。
构建 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
< source >( save_directory: strfilename_prefix: str | None = None ) → tuple[str, ...]
通用词汇保存模式的默认实现。 将 self.encoder/self.vocab 保存为 JSON，可选地将 self.bpe_ranks 作为合并规则一并保存。 如果不存在词汇表，则返回空元组。
如果分词器需要自定义保存逻辑（例如 SentencePiece 模型、多个词汇表文件或特殊文件格式），请重写此方法。
ClvpFeatureExtractor
class transformers.ClvpFeatureExtractor
< source >( feature_size = 80sampling_rate = 22050default_audio_length = 6hop_length = 256chunk_length = 30n_fft = 1024padding_value = 0.0mel_norms = Nonereturn_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，则将其用于沿每个 mel 滤波器对对数 mel 频谱图进行归一化。 - return_attention_mask (
bool, 可选, 默认为False) — 是否返回注意力掩码。如果保持默认值，将返回注意力掩码。
构建 CLVP 特征提取器。
该特征提取器继承自 SequenceFeatureExtractor，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。
此类使用自定义的 numpy 实现的 Short Time Fourier Transform 从原始语音中提取对数梅尔频谱特征，其结果应与 PyTorch 中对应的 torch.stft 一致。
__call__
< source >( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | None = Nonetruncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Truepadding: str | None = 'max_length'max_length: int | None = None**kwargs )
参数
- raw_speech (
np.ndarray、list[float]、list[np.ndarray]、list[list[float]]) — 需要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频，而非立体声，即每个时间步对应一个浮点数。 - sampling_rate (
int, 可选) —raw_speech输入所使用的采样率。强烈建议在 forward 调用时传入sampling_rate，以避免静默错误并支持自动语音识别流水线。 - truncation（
bool，可选，默认为True）— 启用截断，将长度超过 max_length 的输入序列截断为 max_length。 - pad_to_multiple_of (
int, 可选) — 如果设置，将把序列填充为所提供值的倍数。这在启用 NVIDIA 硬件（计算能力
>= 7.5，即 Volta 架构）上的 Tensor Cores 使用时尤为有用，或者在 TPU 上使用时也特别有益，因为 TPU 在序列长度为 128 的倍数时性能更佳。 - return_attention_mask (
bool, 可选, 默认为True) — 是否返回注意力掩码。如果保持默认值，将返回注意力掩码。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- padding_value (
float，可选，默认为 0.0) — 用于填充 padding 值/向量的数值。 - max_length (
int，可选) — 输入的最大长度。
ClvpFeatureExtractor 用于从语音样本或 raw_speech 中提取各种与语音相关的特征，例如音高、语调、语速，甚至口齿不清或口吃等发音缺陷。
首先，语音会被填充或截断，使其成为时长为 self.default_audio_length 秒的波形，然后从中提取对数梅尔频谱图。
ClvpProcessor
class transformers.ClvpProcessor
< source >( feature_extractortokenizer )
构建一个 ClvpProcessor，它将特征提取器和分词器封装为单个处理器。
ClvpProcessor 提供了 ClvpFeatureExtractor 和 ClvpTokenizer 的所有功能。有关更多信息，请参阅 ~ClvpFeatureExtractor 和 ~ClvpTokenizer。
__call__
< source >( *argstext = Noneaudio = None**kwargs )
参数
- text (`
) -- The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, setis_split_into_words=True` to avoid ambiguity with batched inputs. - audio（“） — 要准备的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。 如果为 NumPy 数组/PyTorch 张量，每个音频的形状应为 (C, T)，其中 C 为通道数，T 为音频的采样长度。
- return_tensors (
str或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
此方法会将其所有参数转发给 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅该方法的文档字符串。
此方法会将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅该方法的文档字符串。
ClvpModelForConditionalGeneration
class transformers.ClvpModelForConditionalGeneration
< source >( config: ClvpConfig )
参数
- config (ClvpConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
由文本编码器、语音编码器和语音解码器模型组成的复合 CLVP 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- input_features (
torch.Tensor，形状为(batch_size, sequence_length, feature_dim)，可选) — 与输入音频特征对应的张量。可以使用 ClvpFeatureExtractor 获取音频特征。有关详细信息，请参阅 ClvpFeatureExtractor.call()（ClvpProcessor 使用 ClvpFeatureExtractor 来处理音频）。 - conditioning_encoder_inputs_embeds (
torch.Tensor, 可选) —ClvpConditioningEncoder的 inputs_embeds。可用于替代input_ids。 - text_encoder_inputs_embeds (
torch.Tensor, 可选) — 用于替代input_ids传入文本编码器模型的 inputs_embeds。 - attention_mask (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- return_loss (
bool, 可选) — 是否返回对比损失。
返回值
ClvpOutput 或 tuple(torch.Tensor)
ClvpOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（ClvpConfig）和输入。
ClvpModelForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
- loss (
torch.Tensor，形状为(1,)，可选，当return_loss为True时返回) — 用于语音-文本相似度的对比损失。 - speech_ids (
torch.LongTensor，可选) — 由ClvpForCausalLM模型生成的 speech_ids（或语音候选）。 - logits_per_speech（形状为
(speech_batch_size, text_batch_size)的torch.Tensor）—speech_embeds与text_embeds之间的缩放点积分数。这表示语音-文本相似度分数。 - logits_per_text（形状为
(text_batch_size, speech_batch_size)的torch.Tensor）—text_embeds与speech_embeds之间的缩放点积分数。这表示文本-语音相似度分数。 - text_embeds (
torch.Tensor，形状为(batch_size, output_dim) — 通过对文本编码器模型的池化输出应用投影层获得的文本嵌入 - speech_embeds (
torch.Tensor，形状为(batch_size, output_dim) — 通过对语音编码器模型的池化输出应用投影层获得的语音嵌入 - text_model_output (
~modeling_outputs.BaseModelOutputWithPooling，可选) — 文本编码器模型last_hidden_state的池化输出。 - speech_model_output (
~modeling_outputs.BaseModelOutputWithPooling，可选) — 语音编码器模型last_hidden_state的池化输出。 - decoder_hidden_states (
torch.Tensor，可选) — 解码器模型的隐藏状态。 - text_encoder_hidden_states (
torch.Tensor, 可选) — 文本编码器模型的隐藏状态。 - speech_encoder_hidden_states (
torch.Tensor, 可选) — 语音编码器模型的隐藏状态。
示例：
>>> 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 = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]
>>> # 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_sample, 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: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonepad_to_max_mel_tokens: int | None = Noneoutput_hidden_states: bool | None = None**kwargs ) → ClvpOutput or tuple
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 输入文本的 Token。由 ClvpTokenizer 处理得到。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充文本 token 索引执行注意力的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- generation_config (
~generation.GenerationConfig, 可选) — 用作生成调用基础参数化的生成配置。传递给 generate 且与generation_config属性匹配的**kwargs将覆盖这些属性。如果未提供generation_config，则使用默认值，其加载优先级如下：1) 如果存在，则从generation_config.json模型文件中加载；2) 从模型配置中加载。请注意，未指定的参数将继承 GenerationConfig 的默认值，应查阅其文档以参数化生成。 - pad_to_max_mel_tokens (
int, 可选) — 将生成的 speech_ids 填充至指定值。这是为了实现与官方仓库中相同的逻辑，链接：https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 并确保 logits 保持一致。 这不会影响生成质量，因此请避免使用它，因为其效率较低。 - output_hidden_states (
bool, 可选) — 是否返回解码器模型、文本编码器模型和语音编码器模型的隐藏状态。
返回值
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- text_encoder_inputs_embeds (
torch.Tensor, 可选) — 用于替代input_ids传入文本编码器模型的 inputs_embeds。 - attention_mask (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
返回值
ClvpEncoderOutput 或 tuple(torch.Tensor)
ClvpEncoderOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（ClvpConfig）和输入。
此方法可用于从文本中提取 text_embeds。文本嵌入是通过将投影层应用于 CLVP 文本编码器模型的池化输出而获得的。
embeds（形状为
(batch_size, output_dim)的torch.Tensor，可选，当模型以with_projection=True初始化时返回）—— 通过对 pooler_output 应用投影层获得的嵌入。last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层的隐藏状态。pooler_output（形状为
(batch_size, hidden_size)的torch.Tensor）—last_hidden_state的池化输出。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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] = Noneinput_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = None**kwargs ) → torch.Tensor of shape (batch_size, output_dim)
参数
- speech_ids（形状为
(batch_size, num_speech_ids)的torch.LongTensor，可选） — 语音 Token。如果您提供了填充，默认情况下会被忽略。如果提供了 speech_ids，则 input_ids 和 input_features 将被自动忽略。 - input_ids（形状为
(batch_size, sequence_length)的torch.LongTensor，可选） — 输入文本 Token。由 ClvpTokenizer 处理得到。如果未提供 speech_ids，则将使用 input_ids 和 input_features。 - conditioning_encoder_inputs_embeds (
torch.Tensor, 可选) —ClvpConditioningEncoder的 inputs_embeds。可用于替代input_ids。 - attention_mask (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充语音 token 索引执行注意力的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- generation_config (
GenerationConfig，可选) — 如果未提供 speech_ids，则用于控制 speech_ids 生成的生成配置。
返回值
形状为 (batch_size, output_dim) 的 torch.Tensor
通过对 CLVP Speech Model 的池化输出应用投影层而获得的语音嵌入。
此方法可用于提取 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 = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]
>>> # 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_sample, 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
< source >( config: ClvpDecoderConfig )
参数
- config (ClvpDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
顶部带有语言建模头的 CLVP 解码器模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- past_key_values (
~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由past_key_values在解码的先前阶段返回，当use_cache=True或config.use_cache=True.仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入
past_key_values，则默认会初始化 DynamicCache。模型将输出与输入相同的缓存格式。
如果使用了
past_key_values，用户应仅输入未处理的input_ids（即未向该模型提供其过去键值状态的那些），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的全部input_ids。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入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）。
返回值
CausalLMOutputWithCrossAttentions 或 tuple(torch.Tensor)
一个 CausalLMOutputWithCrossAttentions 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（ClvpConfig）和输入。
ClvpForCausalLM 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple(torch.Tensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的交叉注意力权重，用于在交叉注意力头中计算加权平均值。
past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。
ClvpModel
class transformers.ClvpModel
< source >( config: ClvpDecoderConfig )
参数
- config (ClvpDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
未添加任何特定头部的裸 Clvp 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由past_key_values在解码的先前阶段返回，当use_cache=True或config.use_cache=True.仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入
past_key_values，则默认会初始化 DynamicCache。模型将输出与输入相同的缓存格式。
如果使用了
past_key_values，用户应仅输入未处理的input_ids（即未向该模型提供其过去键值状态的那些），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的全部input_ids。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
返回值
BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPastAndCrossAttentions 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（ClvpConfig）和输入。
ClvpModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。如果使用了
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True且config.add_cross_attention=True，或当config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
ClvpEncoder
由 config.num_hidden_layers 个自注意力层组成的 Transformer 编码器。每一层都是一个 ClvpEncoderLayer。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.LongTensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - attention_mask (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1].
返回值
ClvpEncoderOutput 或 tuple(torch.Tensor)
ClvpEncoderOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（ClvpConfig）和输入。
ClvpEncoder 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
embeds（形状为
(batch_size, output_dim)的torch.Tensor，可选，当模型以with_projection=True初始化时返回）—— 通过对 pooler_output 应用投影层获得的嵌入。last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层的隐藏状态。pooler_output（形状为
(batch_size, hidden_size)的torch.Tensor）—last_hidden_state的池化输出。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
ClvpDecoder
由 config.num_hidden_layers 层组成的 Transformer 解码器。每一层都是一个 ClvpDecoderLayer
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由past_key_values在解码的先前阶段返回，当use_cache=True或config.use_cache=True.仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入
past_key_values，则默认会初始化 DynamicCache。模型将输出与输入相同的缓存格式。
如果使用了
past_key_values，用户应仅输入未处理的input_ids（即未向该模型提供其过去键值状态的那些），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的全部input_ids。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
返回值
BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPastAndCrossAttentions 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（ClvpConfig）和输入。
ClvpDecoder 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。如果使用了
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True且config.add_cross_attention=True，或当config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。