# CLVP

## 概述

CLVP（Contrastive Language-Voice Pretrained Transformer）模型由 James Betker 在 [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) 中提出。

该论文的摘要如下：

*近年来，自回归 Transformer 和 DDPM 的应用彻底改变了图像生成领域。这些方法将图像生成过程建模为逐步的概率过程，并利用大量的计算资源和数据来学习图像分布。这种提升性能的方法并不局限于图像领域。本文介绍了一种将图像生成领域的最新进展应用于语音合成的方法。其成果是 TorToise——一个富有表现力、支持多音色的文本转语音系统。*

该模型由 [Susnato Dhar](https://huggingface.co/susnato) 贡献。原始代码可在[此处](https://github.com/neonbjb/tortoise-tts)找到。

## 使用技巧

1. CLVP 是 Tortoise TTS 模型的重要组成部分。
2. CLVP 可用于将不同的生成语音候选项与提供的文本进行比较，并将最佳的语音 token 传递给扩散模型。
3. 强烈建议使用 `ClvpModelForConditionalGeneration.generate()` 方法来使用 tortoise。
4. 请注意，与其他期望 16 kHz 采样率的音频模型不同，CLVP 模型期望音频以 22.05 kHz 进行采样。

## 简要说明

- [ClvpTokenizer](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpTokenizer) 对文本输入进行分词，[ClvpFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpFeatureExtractor) 从目标音频中提取对数梅尔频谱图。
- `ClvpConditioningEncoder` 接收这些文本 token 和音频表示，并将其转换为基于文本和音频条件的嵌入。
- [ClvpForCausalLM](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpForCausalLM) 使用这些嵌入来生成多个语音候选项。
- 每个语音候选项都会通过语音编码器（[ClvpEncoder](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpEncoder)）进行处理，将其转换为向量表示；文本编码器（[ClvpEncoder](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpEncoder)）则将文本标记转换到相同的潜在空间中。
- 最后，我们将每个语音向量与文本向量进行比较，以查看哪个语音向量与文本向量最为相似。
- `ClvpModelForConditionalGeneration.generate()` 将上述所有逻辑压缩到一个方法中。

示例：

```python
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[[transformers.ClvpConfig]]

#### transformers.ClvpConfig[[transformers.ClvpConfig]]

```python
transformers.ClvpConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, speech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 768, logit_scale_init_value: float = 2.6592, initializer_factor: float = 1.0)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/configuration_clvp.py#L185)

**参数：**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：文本骨干网络的配置对象或字典。

speech_config (`dict`, *可选*) : 用于初始化 CLVP 语音编码器的配置选项字典。

decoder_config (`dict`, *可选*) : 用于初始化 [ClvpDecoderConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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](https://huggingface.co/susnato/clvp_dev) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> 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[[transformers.ClvpEncoderConfig]]

#### transformers.ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

```python
transformers.ClvpEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 256, hidden_size: int = 768, intermediate_size: int = 1536, projection_dim: int = 768, num_hidden_layers: int = 20, num_attention_heads: int = 12, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, use_rotary_embedding: bool = True, use_attention_bias: bool = False, summary_type: str = 'mean', initializer_factor: float = 1.0, bos_token_id: int | None = 255, eos_token_id: int | list[int] | None = 0, pad_token_id: int | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/configuration_clvp.py#L29)

**参数：**

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](https://huggingface.co/susnato/clvp_dev) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> 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[[transformers.ClvpDecoderConfig]]

#### transformers.ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

```python
transformers.ClvpDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 8194, max_position_embeddings: int = 608, max_text_tokens: int = 404, hidden_size: int = 1024, num_hidden_layers: int = 30, num_attention_heads: int = 16, n_inner: int | None = None, num_mel_attn_blocks: int = 6, activation_function: str = 'gelu_new', resid_pdrop: float | int = 0.1, embd_pdrop: float | int = 0.1, attention_dropout: float | int = 0.1, layer_norm_epsilon: float = 1e-05, initializer_range: float = 0.02, summary_type: str = 'cls_index', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, use_cache: bool = True, bos_token_id: int | None = 8192, eos_token_id: int | list[int] | None = 8193, pad_token_id: int | None = None, feature_size: int = 80, use_attention_bias: bool = True, initializer_factor: float = 1.0, decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248), add_cross_attention: bool = False)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/configuration_clvp.py#L103)

**参数：**

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"`：提供一个表示分类 token 位置的 Tensor（类似 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](https://huggingface.co/susnato/clvp_dev) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> 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[[transformers.ClvpTokenizer]]

#### transformers.ClvpTokenizer[[transformers.ClvpTokenizer]]

```python
transformers.ClvpTokenizer(vocab_file, merges_file, errors = 'replace', unk_token = '[UNK]', bos_token = '<|endoftext|>', eos_token = '[STOP]', pad_token = '[STOP]', add_prefix_space = False, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/tokenization_clvp.py#L73)

**参数：**

vocab_file (`str`) : 词汇表文件的路径。

merges_file (`str`) : 合并文件的路径。

errors (`str`，*可选*，默认为 `"replace"`)：将字节解码为 UTF-8 时遵循的范式。更多信息请参阅 [bytes.decode](https://docs.python.org/3/library/stdtypes.html#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），因此一个单词将

无论是否位于句首（无空格），其编码方式均有所不同：

```python
>>> 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](/docs/transformers/v5.23.0/zh/main_classes/tokenizer#transformers.PythonBackend)，后者包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

#### save_vocabulary[[transformers.ClvpTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1365)

**参数：**

save_directory (`str`) : 用于保存词汇表的目录。

filename_prefix (`str`, *可选*) : 一个可选的前缀，用于添加到保存文件的名称中。

**返回：** `tuple[str, ...]`

已保存文件的路径，如果没有保存任何文件，则为空元组。

用于常见词汇表保存模式的默认实现。将 self.encoder/self.vocab 保存为 JSON，可选地将 self.bpe_ranks 作为合并规则一并保存。如果不存在词汇表，则返回空元组。

如果分词器需要自定义保存逻辑（例如 SentencePiece 模型、多个词汇文件或特殊文件格式），请重写此方法。

## ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

#### transformers.ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

```python
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)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/feature_extraction_clvp.py#L30)

**参数：**

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 (`list`，长度为 `feature_size`，*可选*) : 如果提供了 `mel_norms`，则它将用于沿每个 mel 滤波器对对数 mel 频谱图进行归一化。

return_attention_mask (`bool`，*可选*，默认为 `False`)：是否返回注意力掩码。如果保持默认值，它将返回注意力掩码。[什么是注意力掩码？](../glossary#attention-mask)

构建 CLVP 特征提取器。

此特征提取器继承自 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/zh/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)，后者包含了大部分主要方法。有关这些方法的更多信息，请参阅该父类。

此类使用自定义的 numpy 实现的`Short Time Fourier Transform`从原始语音中提取对数梅尔频谱特征，其结果应与 pytorch 的`torch.stft`等效。

#### __调用__[[transformers.ClvpFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = True, padding: str | None = 'max_length', max_length: int | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/feature_extraction_clvp.py#L128)

**参数：**

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`, *optional*) : 如果设置，则将序列填充为所提供值的倍数。 这对于在计算能力 `>= 7.5`（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用，或者对于受益于序列长度为 128 的倍数的 TPU 也很有用。

return_attention_mask (`bool`，*可选*，默认为 `True`)：是否返回注意力掩码。如果保持默认值，则会返回注意力掩码。[什么是注意力掩码？](../glossary#attention-mask)

return_tensors (`str` 或 [TensorType](/docs/transformers/v5.23.0/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。

padding_value (`float`，*可选*，默认值为 0.0)：用于填充填充值/向量的数值。

max_length (`int`, *可选*) : 输入的最大长度。

`ClvpFeatureExtractor` 用于从语音样本或 `raw_speech` 中提取各种与语音相关的属性，例如音高、语调、语速，甚至口齿不清或口吃等发音缺陷。

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

## ClvpProcessor[[transformers.ClvpProcessor]]

#### transformers.ClvpProcessor[[transformers.ClvpProcessor]]

```python
transformers.ClvpProcessor(feature_extractor, tokenizer)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/processing_clvp.py#L27)

**参数：**

feature_extractor (`ClvpFeatureExtractor`)：特征提取器是必需的输入。

tokenizer (`ClvpTokenizer`)：分词器是必需的输入。

构建一个 ClvpProcessor，它将特征提取器和分词器封装为单个处理器。

[ClvpProcessor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpProcessor) 提供了 [ClvpFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpFeatureExtractor) 和 [ClvpTokenizer](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpTokenizer) 的所有功能。有关更多信息，请参阅 [~ClvpFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpFeatureExtractor) 和 [~ClvpTokenizer](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpTokenizer)。

#### __调用__[[transformers.ClvpProcessor.__call__]]

```python
__call__(*args, text = None, audio = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/processing_clvp.py#L31)

**参数：**

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, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

audio (``) : 要准备的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。对于 NumPy 数组/PyTorch 张量，每个音频的形状应为 (C, T)，其中 C 是通道数，T 是音频的采样长度。

return_tensors (`str` 或 [TensorType](/docs/transformers/v5.23.0/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回特定框架的张量。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 NumPy `np.ndarray` 对象。

#### decode[[transformers.ClvpProcessor.decode]]

```python
decode(*args, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2063)

此方法将其所有参数转发给 PreTrainedTokenizer 的 [decode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode)。有关更多信息，请参阅该方法的文档字符串。

#### batch_decode[[transformers.ClvpProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2054)

此方法将其所有参数转发给 PreTrainedTokenizer 的 [batch_decode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode)。有关更多信息，请参阅该方法的文档字符串。

## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

#### transformers.ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

```python
transformers.ClvpModelForConditionalGeneration(config: ClvpConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1247)

**参数：**

config ([ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

由文本编码器、语音编码器和语音解码器模型组成的复合 CLVP 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.ClvpModelForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1452)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

input_features (`torch.Tensor`，形状为 `(batch_size, sequence_length, feature_dim)`，*可选*) : 与输入音频特征对应的张量。可以使用 [ClvpFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpFeatureExtractor) 获取音频特征。有关详细信息，请参阅 [ClvpFeatureExtractor.__call__()](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__)（[ClvpProcessor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpProcessor) 使用 [ClvpFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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。 [什么是注意力掩码？](../glossary#attention-mask)

return_loss (`bool`, *可选*) : 是否返回对比损失。

**返回：** `ClvpOutput` 或 `tuple(torch.Tensor)`

`ClvpOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig)）和输入。

[ClvpModelForConditionalGeneration](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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**（形状为 `(batch_size, output_dim` 的 `torch.Tensor`）-- 通过对文本编码器模型的池化输出应用投影层获得的文本嵌入。
- **speech_embeds**（形状为 `(batch_size, output_dim`) 的 `torch.Tensor`）-- 通过对语音编码器模型的池化输出应用投影层获得的语音嵌入。
- **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`, *可选*) -- 语音编码器模型的隐藏状态。

示例：

```python
>>> 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[[transformers.ClvpModelForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, pad_to_max_mel_tokens: int | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1561)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*) : 输入文本 Tokens。由 [ClvpTokenizer](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpTokenizer) 处理得到。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充文本标记索引执行注意力机制的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 [什么是注意力掩码？](../glossary#attention-mask)

generation_config (`~generation.GenerationConfig`, *可选*) : 用作生成调用基础参数化的生成配置。传递给 generate 且与 `generation_config` 属性匹配的 `**kwargs` 将覆盖这些属性。如果未提供 `generation_config`，则使用默认值，其加载优先级如下：1) 如果存在，则从 `generation_config.json` 模型文件加载；2) 从模型配置加载。请注意，未指定的参数将继承 [GenerationConfig](/docs/transformers/v5.23.0/zh/main_classes/text_generation#transformers.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[[transformers.ClvpModelForConditionalGeneration.get_text_features]]

```python
get_text_features(input_ids: typing.Optional[torch.LongTensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1315)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#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。 [什么是注意力掩码？](../glossary#attention-mask)

**返回：** `ClvpEncoderOutput` 或 `tuple(torch.Tensor)`

`ClvpEncoderOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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 后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

```python
>>> 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[[transformers.ClvpModelForConditionalGeneration.get_speech_features]]

```python
get_speech_features(speech_ids: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1357)

**参数：**

speech_ids (`torch.LongTensor`，形状为 `(batch_size, num_speech_ids)`，*可选*) : 语音 Token。如果您提供了填充，默认情况下将被忽略。如果提供了 speech_ids，则 input_ids 和 input_features 将被自动忽略。

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*) : 输入文本 Tokens。由 [ClvpTokenizer](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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)`，*可选*)：用于避免对填充语音标记索引执行注意力的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 [什么是注意力掩码？](../glossary#attention-mask)

generation_config (`GenerationConfig`, *可选*) : 如果未提供 speech_ids，则用于控制 speech_ids 生成的生成配置。

**返回：** 形状为 `(batch_size, output_dim)` 的 `torch.Tensor`

通过对 CLVP 语音模型的池化输出应用投影层获得的语音嵌入。

此方法可用于提取 speech_embeds。语音嵌入通过对 speech_ids 应用语音模型获得。如果未提供 speech_ids，但同时提供了 input_ids 和 input_features，则会先使用解码器模型生成 speech_ids，然后再应用语音模型。

示例：

```python
>>> 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[[transformers.ClvpForCausalLM]]

#### transformers.ClvpForCausalLM[[transformers.ClvpForCausalLM]]

```python
transformers.ClvpForCausalLM(config: ClvpDecoderConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1069)

**参数：**

config ([ClvpDecoderConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpDecoderConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

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

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.ClvpForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1185)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

inputs_embeds (`torch.Tensor`，形状为 `(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`）。

**返回：** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) 或 `tuple(torch.Tensor)`

一个 [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig)）和输入。

[ClvpForCausalLM](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。

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

## ClvpModel[[transformers.ClvpModel]]

#### transformers.ClvpModel[[transformers.ClvpModel]]

```python
transformers.ClvpModel(config: ClvpDecoderConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1013)

**参数：**

config ([ClvpDecoderConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpDecoderConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

未添加任何特定头部的裸 Clvp 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.ClvpModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L1030)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

use_cache (`bool`，*可选*)：如果设置为 `True`，则会返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。

**返回：** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig)）和输入。

[ClvpModel](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/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[[transformers.ClvpEncoder]]

#### transformers.ClvpEncoder[[transformers.ClvpEncoder]]

```python
transformers.ClvpEncoder(config: ClvpEncoderConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L815)

**参数：**

config : ClvpConfig

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

#### forward[[transformers.ClvpEncoder.forward]]

```python
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, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L849)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

inputs_embeds (`torch.LongTensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果您希望对将 `input_ids` 索引转换为相应向量的方式拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。

attention_mask (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

**返回：** `ClvpEncoderOutput` 或 `tuple(torch.Tensor)`

`ClvpEncoderOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig)）和输入。

[ClvpEncoder](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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[[transformers.ClvpDecoder]]

#### transformers.ClvpDecoder[[transformers.ClvpDecoder]]

```python
transformers.ClvpDecoder(config: ClvpDecoderConfig)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L905)

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

#### forward[[transformers.ClvpDecoder.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/clvp/modeling_clvp.py#L937)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/v5.23.0/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`，*可选*)：预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的 `past_key_values` 组成，前提是 `use_cache=True` 或 `config.use_cache=True`。 仅允许 [Cache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

use_cache (`bool`，*可选*)：如果设置为 `True`，则会返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。

**返回：** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[ClvpConfig](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.ClvpConfig)）和输入。

[ClvpDecoder](/docs/transformers/v5.23.0/zh/model_doc/clvp#transformers.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](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.Cache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。