Hugging Face 的徽标

Transformers 文档

CLVP

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

CLVP

概述

CLVP（对比语言-语音预训练 Transformer）模型是由 James Betker 在 通过扩展实现更好的语音合成 中提出的。

该论文的摘要是：

近年来，图像生成领域发生了革命性的变化，这得益于自回归 Transformer 和 DDPM 的应用。这些方法将图像生成过程建模为逐步概率过程，并利用大量的计算和数据来学习图像分布。这种提高性能的方法不必局限于图像。本文描述了一种将图像生成领域的进步应用于语音合成的方法。其结果是 TorToise——一个富有表现力的多语音文本到语音系统。

该模型由 Susnato Dhar 贡献。原始代码可以在 此处 找到。

使用技巧

  1. CLVP 是 Tortoise TTS 模型不可或缺的一部分。
  2. CLVP 可用于将不同的生成的语音候选项与提供的文本进行比较，并将最佳语音标记转发到扩散模型。
  3. 强烈建议在使用 Tortoise 时使用 ClvpModelForConditionalGeneration.generate() 方法。
  4. 请注意，CLVP 模型期望音频的采样率为 22.05 kHz，这与其他期望 16 kHz 的音频模型不同。

简要说明：

  • ClvpTokenizer 对文本输入进行分词，ClvpFeatureExtractor 从所需音频中提取对数梅尔频谱图。
  • ClvpConditioningEncoder 接收这些文本标记和音频表示，并将它们转换为以文本和音频为条件的嵌入。
  • ClvpForCausalLM 使用这些嵌入生成多个语音候选项。
  • 每个语音候选项都通过语音编码器（ClvpEncoder）转换为向量表示，文本编码器（ClvpEncoder）将文本标记转换为相同的潜在空间。
  • 最后，我们将每个语音向量与文本向量进行比较，以查看哪个语音向量与文本向量最相似。
  • ClvpModelForConditionalGeneration.generate() 将上述所有逻辑压缩到一个方法中。

示例

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> sample = ds[0]["audio"]

>>> # Define processor and model.
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output.
>>> processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt")
>>> generated_output = model.generate(**processor_output)

ClvpConfig

类 transformers.ClvpConfig

< >

( text_config = None speech_config = None decoder_config = None projection_dim = 768 logit_scale_init_value = 2.6592 initializer_factor = 1.0 **kwargs )

参数

  • text_config (dict，可选) — 用于初始化 CLVP 文本编码器的配置选项字典。
  • speech_config (dict，可选) — 用于初始化 CLVP 语音编码器的配置选项字典。
  • decoder_config (dict，可选) — 用于初始化 ClvpDecoderConfig 的配置选项字典。
  • projection_dim (int，可选，默认为 768) — 文本和语音投影层的维度。
  • logit_scale_init_value (float，可选，默认为 2.6592) — logit_scale 参数的初始值。根据原始 CLVP 实现使用默认值。
  • initializer_factor (float，可选，默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1.0，内部用于初始化测试）。
  • kwargs (可选) — 关键字参数字典。

ClvpConfig 是用于存储 ClvpModelForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 CLVP 模型，定义文本模型、语音模型和解码器模型配置。使用默认值实例化配置将产生类似于 CLVP susnato/clvp_dev 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例

>>> from transformers import ClvpConfig, ClvpModelForConditionalGeneration

>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()

>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig

>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()

>>> config = ClvpConfig.from_sub_model_configs(config_text, config_speech, decoder_config)

from_sub_model_configs

< >

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

参数

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

返回

ClvpConfig

配置对象的实例

从 CLVP 文本模型配置、CLVP 语音模型配置和 CLVP 解码器模型配置实例化 ClvpConfig（或派生类）。

ClvpEncoderConfig

类 transformers.ClvpEncoderConfig

< >

( vocab_size = 256 hidden_size = 768 intermediate_size = 1536 projection_dim = 768 num_hidden_layers = 20 num_attention_heads = 12 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.1 dropout = 0.1 use_rotary_embedding = True use_attention_bias = False summary_type = 'mean' initializer_factor = 1.0 bos_token_id = 255 eos_token_id = 0 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 256) — CLVP 编码器模型的词汇表大小。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, 可选, 默认为 1536) — Transformer 编码器中“中间”（即前馈）层的维度。
  • projection_dim (int, 可选, 默认为 768) — 投影向量的维度。
  • num_hidden_layers (int, 可选, 默认为 20) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"selu"、"gelu_new" 和 "quick_gelu"。
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。
  • attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
  • dropout (float, 可选, 默认为 0.1) — ClvpEncoderMLP 中前馈层的 dropout 比率。
  • use_rotary_embedding (bool, 可选, 默认为 True) — 是否使用 rotary_embedding。
  • use_attention_bias (bool, 可选, 默认为 False) — 自注意力期间是否在查询、键和值层中使用偏差。
  • summary_type (str, 可选, 默认为 "mean") — 从 last_hidden_state 获取 pooler_output 的策略。支持 "last"、"first"、"mean" 和 "cls_index"。
  • initializer_factor (float, 可选, 默认为 1.0) — 初始化所有权重矩阵的因子（应保持为 1.0，内部用于初始化测试）。
  • bos_token_id (int, 可选, 默认为 255) — 序列开始标记 id。
  • eos_token_id (int, 可选, 默认为 0) — 序列结束标记 id。

这是用于存储 ClvpEncoder 配置的配置类。它用于根据指定的参数实例化 CLVP 文本或 CLVP 语音编码器。使用默认值实例化配置将产生与 CLVP susnato/clvp_dev 架构的编码器类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例

>>> from transformers import ClvpEncoderConfig, ClvpEncoder

>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()

>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ClvpDecoderConfig

类 transformers.ClvpDecoderConfig

< >

( vocab_size = 8194 max_position_embeddings = 608 max_text_tokens = 404 hidden_size = 1024 num_hidden_layers = 30 num_attention_heads = 16 n_inner = None num_mel_attn_blocks = 6 activation_function = 'gelu_new' resid_pdrop = 0.1 embd_pdrop = 0.1 attention_dropout = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 summary_type = 'cls_index' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 use_cache = True bos_token_id = 8192 eos_token_id = 8193 feature_size = 80 use_attention_bias = True initializer_factor = 1.0 decoder_fixing_codes = [83, 45, 45, 248] **kwargs )

参数

  • vocab_size (int, 可选, 默认为 8194) — 模型的词汇量大小。
  • max_position_embeddings (int, 可选, 默认为 608) — 此模型可能使用的梅尔标记的最大序列长度。类似于 GPT2Config 中的 n_positions。
  • max_text_tokens (int, 可选, 默认为 404) — 此模型可能使用的文本标记的最大序列长度。类似于 GPT2Config 中的 n_positions。
  • hidden_size (int, 可选, 默认为 1024) — 嵌入和隐藏状态的维度。
  • num_hidden_layers (int, 可选, 默认为 30) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数量。
  • n_inner (int, 可选) — 内部前馈层的维度。None 将其设置为 hidden_size 的 4 倍。
  • num_mel_attn_blocks (int, 可选, 默认为 6) — 表示 ClvpConditioningEncoder 中自注意力层的数量。
  • activation_function (str, 可选, 默认为 "gelu_new") — 激活函数，可从列表 ["relu", "silu", "gelu", "tanh", "gelu_new"] 中选择。
  • resid_pdrop (float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
  • embd_pdrop (float, 可选, 默认为 0.1) — 嵌入的丢弃率。
  • attention_dropout (float, 可选, 默认为 0.1) — 注意力的丢弃率。
  • layer_norm_epsilon (float, 可选, 默认为 1e-05) — 层归一化层中使用的 epsilon 值。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • summary_type (string, 可选, 默认为 "cls_index") — 执行序列摘要时使用的参数。

    必须是以下选项之一：

    • "last": 取最后一个标记的隐藏状态（如 XLNet）。
    • "first": 取第一个标记的隐藏状态（如 BERT）。
    • "mean": 取所有标记隐藏状态的平均值。
    • "cls_index": 提供一个分类标记位置的张量（如 GPT/GPT-2）。
    • "attn": 目前未实现，使用多头注意力。
  • summary_use_proj (bool, 可选, 默认为 True) — 是否在向量提取后添加投影。
  • summary_activation (str, 可选) — 传递 "tanh" 对输出进行 tanh 激活，任何其他值将导致无激活。
  • summary_proj_to_labels (bool, 可选, 默认为 True) — 投影输出应具有 config.num_labels 个类还是 config.hidden_size 个类。
  • summary_first_dropout (float, 可选, 默认为 0.1) — 投影和激活后使用的 dropout 比率。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  • bos_token_id (int, 可选, 默认为 8192) — 序列开始的标记 ID，用于生成开始。
  • eos_token_id (int, 可选, 默认为 8193) — 序列结束的标记 ID，在方法 ClvpModelForConditionalGeneration.fix_speech_decoder_output() 中用于更正解码器输出。
  • feature_size (int, 可选, 默认为 80) — 提取的梅尔特征的特征维度。此值在 ClvpConditioningEncoder 中使用。
  • use_attention_bias (bool, 可选, 默认为 True) — 自注意力期间是否在查询、键和值层中使用偏差。
  • initializer_factor (float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1.0，内部用于初始化测试）。
  • decoder_fixing_codes (list, 可选, 默认为 [83, 45, 45, 248]) — 这些值在方法 fix_speech_decoder_output 中用于修复解码器生成的输出。

这是用于存储 ClvpDecoder 配置的配置类。它用于根据指定的参数实例化 CLVP 解码器模型，定义模型架构。使用默认值实例化配置将产生与 CLVP susnato/clvp_dev 架构的解码器部分类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

该架构类似于 GPT2。

示例

>>> from transformers import ClvpDecoderConfig, ClvpDecoder

>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()

>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ClvpTokenizer

类 transformers.ClvpTokenizer

< >

( vocab_file merges_file errors = 'replace' unk_token = '[UNK]' bos_token = '<|endoftext|>' eos_token = '[STOP]' pad_token = '[STOP]' add_prefix_space = False add_bos_token = False add_eos_token = False **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • merges_file (str) — 合并文件的路径。
  • errors (str, 可选, 默认为 "replace") — 将字节解码为 UTF-8 时要遵循的范例。请参阅 bytes.decode 了解更多信息。
  • unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，将被设置为该标记。
  • bos_token (str，可选，默认为 "<|endoftext|>") — 序列开始标记。
  • eos_token (str，可选，默认为 "[STOP]") — 序列结束标记。
  • pad_token (str，可选，默认为 "[STOP]") — 序列的填充标记。
  • add_prefix_space (bool，可选，默认为 False) — 是否在输入开头添加空格。这允许将前导词与其他任何词一样对待。（CLVP 分词器通过前面的空格检测词的开头）。
  • add_bos_token (bool，可选，默认为 False) — 当 add_special_tokens=True 时，是否在序列前面添加 bos_token。
  • add_eos_token (bool，可选，默认为 False) — 当 add_special_tokens=True 时，是否在序列末尾添加 eos_token。

构造一个 CLVP 分词器。基于字节级别的字节对编码。

此分词器经过训练，将空格视为标记的一部分（有点像 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_directory: str filename_prefix: Optional = None )

ClvpFeatureExtractor

类 transformers.ClvpFeatureExtractor

< >

( feature_size = 80 sampling_rate = 22050 default_audio_length = 6 hop_length = 256 chunk_length = 30 n_fft = 1024 padding_value = 0.0 mel_norms = None return_attention_mask = False **kwargs )

参数

  • feature_size (int, 可选, 默认为 80) — 提取特征的特征维度。
  • sampling_rate (int, 可选, 默认为 22050) — 音频文件应数字化的采样率，以赫兹 (Hz) 表示。
  • default_audio_length (int, 可选, 默认为 6) — 原始音频的默认长度（以秒为单位）。如果在 __call__ 期间未设置 max_length，则它将自动设置为 default_audio_length * self.sampling_rate。
  • hop_length (int, 可选, 默认为 256) — 用于获取梅尔频率系数的 STFT 的重叠窗口的长度。
  • chunk_length (int，可选，默认为 30) — 用于修剪和填充较长或较短音频序列的 sampling_rate 样本的最大块数。
  • n_fft (int，可选，默认为 1024) — 傅里叶变换的大小。
  • padding_value (float，可选，默认为 0.0) — 用于填充音频的填充值。 应该对应于静音。
  • mel_norms (长度为 feature_size 的 list，可选) — 如果提供了 mel_norms，则它将用于沿着每个梅尔滤波器对对数梅尔频谱图进行归一化。
  • return_attention_mask (bool，可选，默认为 False) — 是否返回注意力掩码。 如果保留默认值，则它将返回注意力掩码。

    什么是注意力掩码？

构造一个 CLVP 特征提取器。

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

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

__call__

< >

( raw_speech: Union sampling_rate: Optional = None truncation: bool = True pad_to_multiple_of: Optional = None return_tensors: Union = None return_attention_mask: Optional = True padding: Optional = 'max_length' max_length: Optional = None **kwargs )

参数

  • raw_speech (np.ndarray, List[float], List[np.ndarray], List[List[float]]) — 需要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表列表。必须是单声道音频，而不是立体声，即每个时间步长对应一个浮点数。
  • sampling_rate (int, 可选) — 对 raw_speech 输入进行采样的采样率。强烈建议在正向调用时传递 sampling_rate，以防止出现静默错误并允许自动语音识别流水线。
  • truncation (bool, 可选, 默认值为 True) — 激活截断以将长度超过 max_length 的输入序列截断为 max_length。
  • pad_to_multiple_of (int, 可选) — 如果设置，则将序列填充到所提供值的倍数。

    这对于在计算能力 >= 7.5（Volta）的 NVIDIA 硬件或受益于序列长度为 128 的倍数的 TPU 上使用 Tensor Core 特别有用。

  • return_attention_mask (bool, 可选, 默认值为 True) — 是否返回注意力掩码。如果保留默认值，则会返回注意力掩码。

    什么是注意力掩码？

  • return_tensors (str 或 TensorType, 可选) — 如果设置，则返回张量而不是 Python 整数列表。可接受的值为：

    • 'tf'：返回 TensorFlow tf.constant 对象。
    • '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

< >

( feature_extractor tokenizer )

参数

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

构造一个 CLVP 处理器，它将 CLVP 特征提取器和 CLVP 分词器包装到一个处理器中。

ClvpProcessor 提供了 ClvpFeatureExtractor 和 ClvpTokenizer 的所有功能。有关更多信息，请参阅 call()、 decode() 和 batch_decode() 的文档字符串。

__call__

< >

( *args **kwargs )

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

解码

< >

( *args **kwargs )

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

batch_decode

< >

( *args **kwargs )

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

ClvpModelForConditionalGeneration

类 transformers.ClvpModelForConditionalGeneration

< >

( config: ClvpConfig )

参数

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

具有文本编码器、语音编码器和语音解码器模型的复合 CLVP 模型。语音解码器模型根据文本生成 speech_ids，文本编码器和语音编码器协同工作以过滤出最佳的 speech_ids。此模型继承自 PreTrainedModel。查看超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( input_ids: LongTensor = None input_features: FloatTensor = None conditioning_encoder_inputs_embeds: Optional = None text_encoder_inputs_embeds: Optional = None attention_mask: Optional = None return_loss: Optional = None output_hidden_states: Optional = None output_attentions: Optional = False return_dict: Optional = None ) → transformers.models.clvp.modeling_clvp.ClvpOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

  • input_features (torch.FloatTensor 形状为 (batch_size, feature_size, time_dim)) — 表示由 ClvpFeatureExtractor 返回的音频的对数梅尔频谱图表示。
  • conditioning_encoder_inputs_embeds (torch.FloatTensor，可选) — ClvpConditioningEncoder 的 inputs_embeds。可以代替 input_ids 使用。
  • text_encoder_inputs_embeds (torch.FloatTensor，可选) — 代替 input_ids 传递的文本编码器模型的 inputs_embeds。
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length)，可选) — 掩码以避免对填充文本标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 未掩码标记为 1，
    • 已掩码标记为 0。

    什么是注意力掩码？

  • return_loss (bool, 可选) — 是否返回对比损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.clvp.modeling_clvp.ClvpOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.clvp.modeling_clvp.ClvpOutput 或一个 torch.FloatTensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (<class 'transformers.models.clvp.configuration_clvp.ClvpConfig'>) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)，可选，当 return_loss 为 True 时返回) — 语音-文本相似度的对比损失。
  • speech_ids (torch.LongTensor, 可选) — 由 ClvpForCausalLM 模型生成的 speech_ids（或语音候选）。
  • logits_per_speech (torch.FloatTensor 形状为 (speech_batch_size, text_batch_size)) — speech_embeds 和 text_embeds 之间的缩放点积分数。这表示语音-文本相似度分数。
  • logits_per_text (torch.FloatTensor 形状为 (text_batch_size, speech_batch_size)) — text_embeds 和 speech_embeds 之间的缩放点积分数。这表示文本-语音相似度分数。
  • text_embeds (torch.FloatTensor 形状为 (batch_size, output_dim) — 通过将投影层应用于文本编码器模型的池化输出获得的文本嵌入。
  • speech_embeds (torch.FloatTensor 形状为 (batch_size, output_dim) — 通过将投影层应用于语音编码器模型的池化输出获得的语音嵌入。
  • text_model_output (BaseModelOutputWithPooling) — 文本编码器模型的 last_hidden_state 的池化输出。
  • speech_model_output (BaseModelOutputWithPooling) — 语音编码器模型的 last_hidden_state 的池化输出。
  • decoder_hidden_states (torch.FloatTensor, 可选) — 解码器模型的隐藏状态。
  • text_encoder_hidden_states (torch.FloatTensor, 可选) — 文本编码器模型的隐藏状态。
  • speech_encoder_hidden_states (torch.FloatTensor, 可选) — 语音编码器模型的隐藏状态。

ClvpModelForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管前向传递的步骤需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> _, audio, sr = ds.sort("id").select(range(1))[:1]["audio"][0].values()

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
...     input_ids=processor_output["input_ids"],
...     input_features=processor_output["input_features"],
...     return_dict=True,
... )

生成

< >

( input_ids: LongTensor = None input_features: FloatTensor = None attention_mask: Optional = None generation_config: Optional = None pad_to_max_mel_tokens: Optional = None output_hidden_states: Optional = None **kwargs ) → ClvpOutput 或元组

参数

  • input_ids (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 输入文本标记。由 ClvpTokenizer 处理得到。
  • input_features (torch.FloatTensor 形状为 (batch_size, feature_size, time_dim)，可选) — 表示 ClvpFeatureExtractor 返回的音频的对数梅尔频谱图表示。
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免对填充文本标记索引执行注意力。掩码值在 [0, 1] 中选择：

    • 1 表示未被掩码的标记，
    • 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

< >

( input_ids: Optional = None text_encoder_inputs_embeds: Optional = None attention_mask: Optional = None ) → 形状为 (batch_size, output_dim) 的 torch.FloatTensor

参数

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

    什么是输入 ID？

  • text_encoder_inputs_embeds (torch.FloatTensor, 可选) — 传递给文本编码器模型的 inputs_embeds，代替 input_ids。
  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 未被掩码的标记为 1，
    • 被掩码的标记为 0。

    什么是注意力掩码？

返回

形状为 (batch_size, output_dim) 的 torch.FloatTensor

通过将投影层应用于 CLVP 文本模型的池化输出获得的文本嵌入。

此方法可用于从文本中提取 text_embeds。通过将投影层应用于 CLVP 文本编码器模型的池化输出获得的文本嵌入。

示例

>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text
>>> text = "This is an example text."

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])

get_speech_features

< >

( speech_ids: Optional = None input_ids: Optional = None input_features: Optional = None conditioning_encoder_inputs_embeds: Optional = None attention_mask: Optional = None **kwargs ) → 形状为 (batch_size, output_dim) 的 torch.FloatTensor

参数

  • speech_ids (形状为 (batch_size, num_speech_ids) 的 torch.LongTensor，可选) — 语音标记。如果您提供填充，则默认情况下将忽略它。如果提供了 speech_ids，则 input_ids 和 input_features 将被自动忽略。
  • input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 输入文本标记。由 ClvpTokenizer 处理。如果没有提供 speech_ids，则将使用 input_ids 和 input_features。
  • input_features (形状为 (batch_size, feature_size, time_dim) 的 torch.FloatTensor，可选) — 表示由 ClvpFeatureExtractor 返回的音频的对数梅尔频谱图表示。如果没有提供 speech_ids，则将使用 input_ids 和 input_features。
  • conditioning_encoder_inputs_embeds (torch.FloatTensor，可选) — ClvpConditioningEncoder 的 inputs_embeds。可以用来代替 input_ids。
  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 掩码，用于避免对填充语音标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 1 表示未被掩码的标记，
    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • generation_config (GenerationConfig, 可选) — 用于控制 speech_ids 生成的生成配置（如果未提供）。

返回

形状为 (batch_size, output_dim) 的 torch.FloatTensor

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

此方法可用于提取 speech_embeds。语音嵌入是通过在 speech_ids 上应用语音模型获得的。如果 speech_ids 不存在，但同时提供了 input_ids 和 input_features，则将使用解码器模型首先生成 speech_ids，然后应用语音模型。

示例

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> _, audio, sr = ds.sort("id").select(range(1))[:1]["audio"][0].values()

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
...     input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )

ClvpForCausalLM

类 transformers.ClvpForCausalLM

< >

( config )

参数

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

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — 词汇表中输入序列标记的索引。

    索引可以通过 AutoTokenizer 获取。 更多细节请参考 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • past_key_values (长度为 config.n_layers 的 Tuple[Tuple[torch.Tensor]]) — 包含模型计算的预先计算的隐藏状态（注意力块中的键和值）（请参见下面的 past_key_values 输出）。可用于加速序列解码。已经计算过的 input_ids 不应作为 input_ids 传递给此模型，因为它们已经被计算过了。
  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 避免对填充标记索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 未被掩码 的标记为 1，
    • 被掩码 的标记为 0。

    如果使用 past_key_values，则 attention_mask 需要包含用于 past_key_values 的掩码策略。换句话说，attention_mask 始终必须具有长度：len(past_key_values) + len(input_ids)

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, input_ids_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A 标记，
    • 1 对应于 句子 B 标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是位置 ID？

  • head_mask (torch.FloatTensor 形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想更好地控制如何将 input_ids 索引转换为关联向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

    如果使用 past_key_values，则可以选择只输入最后的 inputs_embeds（请参阅 past_key_values）。

  • use_cache (bool, 可选) — 如果设置为 True，则会返回 past_key_values 键值状态，并可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于语言建模的标签。请注意，标签在模型内部是**移位的**，即您可以设置 labels = input_ids 索引在 [-100, 0, ..., config.vocab_size] 中选择 所有设置为 -100 的标签都将被忽略（屏蔽），损失仅针对 [0, ..., config.vocab_size] 中的标签计算

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

尽管前向传递的步骤需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

ClvpModel

类 transformers.ClvpModel

< >

( config: ClvpDecoderConfig )

参数

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

基本的 Clvp 解码器模型，输出原始隐藏状态，没有任何特定头部。 此模型继承自 PreTrainedModel。 请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

  • past_key_values (长度为 config.n_layers 的 Tuple[Tuple[torch.Tensor]]) — 包含模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的 past_key_values 输出）。 可用于加速顺序解码。 其过去值已传递给此模型的 input_ids 不应作为 input_ids 传递，因为它们已被计算。
  • attention_mask (torch.FloatTensor ，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值在 [0, 1] 中选择：

    • 1 表示标记未被掩码，
    • 0 表示标记已被掩码。

    如果使用了 past_key_values，则 attention_mask 需要包含用于 past_key_values 的掩码策略。换句话说，attention_mask 始终必须具有以下长度：len(past_key_values) + len(input_ids)

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor ，形状为 (batch_size, input_ids_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于句子 A 标记，
    • 1 对应于句子 B 标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor ，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是位置 ID？

  • head_mask (torch.FloatTensor ，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 掩码，用于将自注意力模块的选定头部置零。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被掩码，
    • 0 表示头部已被掩码。
  • inputs_embeds (torch.FloatTensor ，形状为 (batch_size, sequence_length, hidden_size)，可选) — 或者，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想更好地控制如何将 input_ids 索引转换为关联向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

    如果使用了 past_key_values，则可以选择仅输入最后的 inputs_embeds（请参阅 past_key_values）。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的元组。

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

尽管前向传递的步骤需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

ClvpEncoder

类 transformers.ClvpEncoder

< >

( config: ClvpConfig )

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

forward

< >

( input_ids: Optional = None inputs_embeds: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor ，形状为 (batch_size, input_ids_length)，可选) — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

  • inputs_embeds (torch.FloatTensor ，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型的输入嵌入。这会绕过模型的内部嵌入查找矩阵。
  • attention_mask (torch.LongTensor ，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 未被掩码 的标记为 1，
    • 被掩码 的标记为 0。

    什么是注意力掩码？

  • position_ids (torch.LongTensor，可选) — 表示 input_ids 的位置 ID。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

ClvpDecoder

类 transformers.ClvpDecoder

< >

( config )

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

forward

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — 词汇表中输入序列词元的索引。

    索引可以通过 AutoTokenizer 获取。 更多详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • past_key_values (Tuple[Tuple[torch.Tensor]] 长度为 config.n_layers) — 包含模型计算的预先计算的隐藏状态（注意力块中的键和值）（参见下面的 past_key_values 输出）。可用于加速序列解码。将过去传递给此模型的 input_ids 不应作为 input_ids 传递，因为它们已被计算。
  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 掩码避免在填充词元索引上执行注意力。掩码值在 [0, 1] 中选择：

    • 未被掩码 的词元为 1，
    • 被掩码 的词元为 0。

    如果使用 past_key_values，则 attention_mask 需要包含用于 past_key_values 的掩码策略。换句话说，attention_mask 始终必须具有长度：len(past_key_values) + len(input_ids)

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, input_ids_length), 可选) — 段落标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A 标记,
    • 1 对应于 句子 B 标记.

    什么是标记类型 ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是位置 ID？

  • head_mask (torch.FloatTensor 形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被屏蔽,
    • 0 表示头部已被屏蔽.
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想更好地控制如何将 input_ids 索引转换为关联向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

    如果使用 past_key_values，则可以选择仅输入最后的 inputs_embeds（参见 past_key_values）。

  • use_cache (bool, 可选) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

ClvpDecoder 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管前向传递的步骤需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

< > 在 GitHub 上更新

←CLIPSeg Data2Vec→