# CLAP

[CLAP（Contrastive Language-Audio Pretraining，对比语言-音频预训练）](https://huggingface.co/papers/2211.06687) 是一种多模态模型，它通过对比学习将音频数据与自然语言描述相结合。

它融合了特征融合和关键词到字幕的增强技术，以处理变长音频输入并提升性能。CLAP 无需任务特定的训练数据，即可通过自然语言学习有意义的音频表示。

您可以在 [CLAP](https://huggingface.co/collections/laion/clap-contrastive-language-audio-pretraining-65415c0b18373b607262a490) 集合中找到所有原始的 CLAP 检查点。

> [!TIP]
> 该模型由 [ybelkada](https://huggingface.co/ybelkada) 和 [ArthurZ](https://huggingface.co/ArthurZ) 贡献。
>
> 点击右侧边栏中的 CLAP 模型，以查看将 CLAP 应用于不同音频检索和分类任务的更多示例。

以下示例演示了如何使用 [AutoModel](/docs/transformers/main/zh/model_doc/auto#transformers.AutoModel) 类提取文本嵌入。

```python
import torch

from transformers import AutoModel, AutoTokenizer

model = AutoModel.from_pretrained("laion/clap-htsat-unfused", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

texts = ["the sound of a cat", "the sound of a dog", "music playing"]

inputs = tokenizer(texts, padding=True, return_tensors="pt").to(model.device)

with torch.no_grad():
    text_features = model.get_text_features(**inputs)

print(f"Text embeddings shape: {text_features.shape}")
print(f"Text embeddings: {text_features}")
```

## ClapConfig[[transformers.ClapConfig]]

#### transformers.ClapConfig[[transformers.ClapConfig]]

```python
transformers.ClapConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, logit_scale_init_value: float = 14.285714285714285, projection_dim: int = 512, projection_hidden_act: str = 'relu', initializer_factor: float = 1.0)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/configuration_clap.py#L145)

**参数：**

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

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

logit_scale_init_value (`float`, *可选*, 默认为 `14.285714285714285`) : *logit_scale* 参数的初始值。

projection_dim (`int`，*可选*，默认值为 `512`)：文本和视觉投影层的维度。

projection_hidden_act (`str`，*可选*，默认为 `relu`)：多模态投影器使用的激活函数。

initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。

这是用于存储 ClapModel 配置的类。它根据指定的参数实例化 Clap 模型，并定义模型架构。使用默认值实例化配置将得到与 [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused) 类似的配置。

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

示例：

```python
>>> from transformers import ClapConfig, ClapModel

>>> # Initializing a ClapConfig with laion-ai/base style configuration
>>> configuration = ClapConfig()

>>> # Initializing a ClapModel (with random weights) from the laion-ai/base style configuration
>>> model = ClapModel(configuration)

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

>>> # We can also initialize a ClapConfig from a ClapTextConfig and a ClapAudioConfig
>>> from transformers import ClapTextConfig, ClapAudioConfig

>>> # Initializing a ClapText and ClapAudioConfig configuration
>>> config_text = ClapTextConfig()
>>> config_audio = ClapAudioConfig()

>>> config = ClapConfig(text_config=config_text, audio_config=config_audio)
```

## ClapTextConfig[[transformers.ClapTextConfig]]

#### transformers.ClapTextConfig[[transformers.ClapTextConfig]]

```python
transformers.ClapTextConfig(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 = 50265, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 514, type_vocab_size: int = 1, initializer_factor: float = 1.0, layer_norm_eps: float = 1e-12, projection_dim: int = 512, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, projection_hidden_act: str = 'relu')
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/configuration_clap.py#L27)

**参数：**

vocab_size (`int`，*可选*，默认为 `50265`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：注意力概率的 dropout 比率。

max_position_embeddings (`int`，*可选*，默认值为 `514`)：该模型可能使用的最大序列长度。

type_vocab_size (`int`，*可选*，默认为 `1`)：`token_type_ids` 的词汇表大小。

initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

projection_dim (`int`，*可选*，默认值为 `512`)：文本和视觉投影层的维度。

pad_token_id (`int`，*可选*，默认为 `1`)：词表中用于填充的 token id。

bos_token_id (`int`，*可选*，默认为 `0`)：词汇表中用于表示流开始的 token id。

eos_token_id (`Union[int, list[int]]`，*可选*，默认为 `2`)：词汇表中用于表示流结束（end-of-stream）的 token id。

projection_hidden_act (`str`，*可选*，默认为 `relu`)：多模态投影器使用的激活函数。

这是用于存储 ClapModel 配置的类。它根据指定的参数实例化 Clap 模型，并定义模型架构。使用默认值实例化配置将得到与 [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused) 类似的配置。

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

示例：

```python
>>> from transformers import ClapTextConfig, ClapTextModel

>>> # Initializing a CLAP text configuration
>>> configuration = ClapTextConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = ClapTextModel(configuration)

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

## ClapAudioConfig[[transformers.ClapAudioConfig]]

#### transformers.ClapAudioConfig[[transformers.ClapAudioConfig]]

```python
transformers.ClapAudioConfig(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, window_size: int = 8, num_mel_bins: int = 64, spec_size: int = 256, hidden_act: str = 'gelu', patch_size: int | list[int] | tuple[int, int] = 4, patch_stride: int | list[int] | tuple[int, ...] = (4, 4), num_classes: int = 527, hidden_size: int = 768, projection_dim: int = 512, depths: list[int] | tuple[int, ...] = (2, 2, 6, 2), num_attention_heads: list[int] | tuple[int, ...] = (4, 8, 16, 32), enable_fusion: bool = False, hidden_dropout_prob: float | int = 0.1, fusion_type: str | None = None, patch_embed_input_channels: int = 1, flatten_patch_embeds: bool = True, patch_embeds_hidden_size: int = 96, enable_patch_layer_norm: bool = True, drop_path_rate: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, qkv_bias: bool = True, mlp_ratio: float = 4.0, aff_block_r: int = 4, num_hidden_layers: int = 4, projection_hidden_act: str = 'relu', layer_norm_eps: float = 1e-05, initializer_factor: float = 1.0)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/configuration_clap.py#L68)

**参数：**

window_size (`int`，*可选*，默认为 8)：频谱图的大小

num_mel_bins (`int`，*可选*，默认为 `64`)：每个输入帧使用的 mel 特征数量。应与 `AutoFeatureExtractor` 类中使用的值对应。

spec_size (`int`，*可选*，默认为 256)：模型支持的频谱图期望输入大小。它可以与 `ClapFeatureExtractor` 的输出不同，在这种情况下，输入特征将被调整大小。对应于音频模型的 `image_size`。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

patch_size (`Union[int, list[int], tuple[int, int]]`，*可选*，默认为 `4`)：每个 patch 的大小（分辨率）。

patch_stride (`list`，*可选*，默认为 `[4, 4]`)：音频频谱图的补丁步长

num_classes (`int`，*可选*，默认为 527)：用于头部训练的类别数

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

projection_dim (`int`，*可选*，默认值为 `512`)：文本和视觉投影层的维度。

depths (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(2, 2, 6, 2)`)：Transformer 中每一层的深度。

num_attention_heads (`Union[list[int], tuple[int, ...]]`，*可选*，默认为 `(4, 8, 16, 32)`)：Transformer 解码器中每个注意力层的注意力头数量。

enable_fusion (`bool`，*可选*，默认为 `False`)：是否启用 patch fusion。这是作者的主要贡献，应能带来最佳效果。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

fusion_type (`[type]`，*可选*)：用于补丁融合的融合类型。

patch_embed_input_channels (`int`，*可选*，默认为 1)：用于输入频谱图的通道数

flatten_patch_embeds (`bool`，*可选*，默认为 `True`)：是否展平补丁嵌入

patch_embeds_hidden_size (`int`，*可选*，默认为 96)：补丁嵌入的隐藏层大小。它用作输出通道的数量。

enable_patch_layer_norm (`bool`, *可选*, 默认为 `True`) : 是否启用用于 patch 嵌入的层归一化

drop_path_rate (`Union[float, int]`，*可选*，默认为 `0.0`)：用于 patch 融合的 drop path 比率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

qkv_bias (`bool`，*可选*，默认为 `True`)：是否向查询、键和值添加偏置。

mlp_ratio (`float`, *可选*, 默认为 `4.0`) : MLP 隐藏维度与嵌入维度的比率。

aff_block_r (`int`，*可选*，默认为 4)：在 AudioFF 块中使用的 downsize_ratio

num_hidden_layers (`int`，*可选*，默认为 `4`)：Transformer 解码器中的隐藏层数。

projection_hidden_act (`str`，*可选*，默认为 `relu`)：多模态投影器使用的激活函数。

layer_norm_eps (`float`，*可选*，默认为 `1e-05`)：层归一化层所使用的 epsilon。

initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。

这是用于存储 ClapModel 配置的类。它根据指定的参数实例化 Clap 模型，并定义模型架构。使用默认值实例化配置将得到与 [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused) 类似的配置。

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

示例：

```python
>>> from transformers import ClapAudioConfig, ClapAudioModel

>>> # Initializing a ClapAudioConfig with laion/clap-htsat-fused style configuration
>>> configuration = ClapAudioConfig()

>>> # Initializing a ClapAudioModel (with random weights) from the laion/clap-htsat-fused style configuration
>>> model = ClapAudioModel(configuration)

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

## ClapFeatureExtractor[[transformers.ClapFeatureExtractor]]

#### transformers.ClapFeatureExtractor[[transformers.ClapFeatureExtractor]]

```python
transformers.ClapFeatureExtractor(feature_size = 64, sampling_rate = 48000, hop_length = 480, max_length_s = 10, fft_window_size = 1024, padding_value = 0.0, return_attention_mask = False, frequency_min: float = 0, frequency_max: float = 14000, top_db: int | None = None, truncation: str = 'fusion', padding: str = 'repeatpad', **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/feature_extraction_clap.py#L36)

**参数：**

feature_size (`int`，*可选*，默认为 64)：提取的梅尔频谱的特征维度。这对应于梅尔滤波器的数量（`n_mels`）。

sampling_rate (`int`, *可选*，默认为 48000)：音频文件应被数字化时的采样率，以赫兹 (Hz) 为单位。此参数仅用于在输入到特征提取器的音频采样率不一致时向用户发出警告。

hop_length (`int`,*optional*, defaults to 480) : Length of the overlapping windows for the STFT used to obtain the Mel Spectrogram. The audio will be split in smaller `frames` with a step of `hop_length` between each frame.

max_length_s (`int`, *可选*，默认为 10)：模型的最大输入长度（以秒为单位）。此参数用于填充音频。

fft_window_size (`int`, *可选*，默认为 1024) : 应用傅里叶变换的窗口大小（以采样点为单位）。这控制着频谱图的频率分辨率。400 表示在 400 个采样点的窗口上计算傅里叶变换。

padding_value (`float`, *可选*, 默认值为 0.0) : 用于填充音频的填充值。应对应静音。

return_attention_mask (`bool`, *可选*, 默认为 `False`) : 模型是否应返回与输入对应的注意力掩码。

frequency_min (`float`, *可选*，默认为 0)：感兴趣的最低频率。STFT 不会计算低于此值的频率。

frequency_max (`float`, *可选*，默认为 14000)：感兴趣的最高频率。STFT 不会计算高于此值的部分。

top_db (`float`, *可选*) : 用于将梅尔频谱图转换为对数尺度的最大分贝值。更多详情请参见 `audio_utils.power_to_db` 函数

truncation (`str`, *可选*, 默认为 `"fusion"`) : 长音频输入的截断模式。提供两种模式： - `fusion` 将使用 `_random_mel_fusion`，该方法将梅尔频谱图中 3 个随机裁剪区域与整个梅尔频谱图的降采样版本堆叠在一起。如果 `config.fusion` 设置为 True，较短的音频也需要返回 4 个梅尔，这仅仅是从填充后的音频中获取的原始梅尔的副本。 - `rand_trunc` 将选择梅尔频谱图的一个随机裁剪区域。

padding (`str`, *可选*, 默认为 `"repeatpad"`) : 用于较短音频输入的填充模式。最初实现了三种模式： - `repeatpad`：重复音频，然后填充以适配 `max_length`。 - `repeat`：重复音频，然后截断以适配 `max_length` - `pad`：对音频进行填充。

构建 CLAP 特征提取器。

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

此类使用自定义的 numpy 实现的*短时傅里叶变换*（STFT）从原始语音中提取梅尔滤波器组特征，其结果应与 pytorch 的`torch.stft`等效。

#### to_dict[[transformers.ClapFeatureExtractor.to_dict]]

```python
to_dict()
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/feature_extraction_clap.py#L141)

**返回：** `dict[str, Any]`

构成此配置实例的所有属性的字典，但不包括 mel 滤波器组，因为它们太长，无需保存或打印。

将此实例序列化为 Python 字典。

## ClapProcessor[[transformers.ClapProcessor]]

#### transformers.ClapProcessor[[transformers.ClapProcessor]]

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

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/processing_clap.py#L26)

**参数：**

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

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

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

[ClapProcessor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapProcessor) 提供了 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 和 [RobertaTokenizer](/docs/transformers/main/zh/model_doc/led#transformers.RobertaTokenizer) 的所有功能。有关更多信息，请参阅 [~ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 和 [~RobertaTokenizer](/docs/transformers/main/zh/model_doc/led#transformers.RobertaTokenizer)。

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

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659)

**参数：**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *可选*) : 要预处理的图像。期望输入单张图像或一批图像，其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 `do_rescale=False`。

text (`Union[str, list[str], list[list[str]]]`，*可选*)：要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果传入预分词输入，请设置 `is_split_into_words=True` 以避免与批量输入产生歧义。

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`，*可选*)：要预处理的视频。期望输入单个视频或一批视频，其像素值范围为 0 到 255。如果传入的像素值在 0 到 1 之间，请设置 `do_rescale=False`。

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`，*可选*)：要准备处理的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。对于 NumPy 数组/PyTorch 张量，每个音频的形状应为 (C, T)，其中 C 是通道数，T 是音频的采样长度。

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

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/zh/main_classes/processors#transformers.ProcessingKwargs), *可选*) : 针对每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

## ClapModel[[transformers.ClapModel]]

#### transformers.ClapModel[[transformers.ClapModel]]

```python
transformers.ClapModel(config: ClapConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1432)

**参数：**

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

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

该模型继承自 [PreTrainedModel](/docs/transformers/main/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.ClapModel.forward]]

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

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1537)

**参数：**

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

input_features (`torch.Tensor`，形状为 `(batch_size, sequence_length, feature_dim)`，*可选*) : 与输入音频特征对应的张量。可以使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 获取音频特征。有关详细信息，请参阅 `ClapFeatureExtractor.__call__()`（[ClapProcessor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapProcessor) 使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 处理音频）。

is_longer (`torch.Tensor`，形状为 `(batch_size, 1)`，*可选*)：音频片段是否长于 `max_length`。如果为 `True`，将启用特征融合以增强特征。

attention_mask (`torch.Tensor`，形状为 `(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)

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

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

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

[ClapModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当 `return_loss` 为 `True` 时返回) -- 用于音频-文本相似度的对比损失。
- **logits_per_audio**（形状为 `(audio_batch_size, text_batch_size)` 的 `torch.Tensor`）-- `audio_embeds` 与 `text_embeds` 之间的缩放点积分数。这表示音频-文本相似度分数。
- **logits_per_text**（形状为 `(text_batch_size, audio_batch_size)` 的 `torch.Tensor`）-- `text_embeds` 与 `audio_embeds` 之间的缩放点积分数。这表示文本-音频相似度分数。
- **text_embeds** (`torch.Tensor`，形状为 `(batch_size, output_dim`) -- 通过对 [ClapTextModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapTextModel) 的池化输出应用投影层获得的文本嵌入。
- **audio_embeds** (`torch.Tensor`，形状为 `(batch_size, output_dim`) -- 通过对 [ClapAudioModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapAudioModel) 的池化输出应用投影层获得的音频嵌入。
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`，*可选*) -- [ClapTextModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapTextModel) 的输出。
- **audio_model_output**（`~modeling_outputs.BaseModelOutputWithPooling`，*可选*）-- [ClapAudioModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapAudioModel) 的输出。

示例：

```python
>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, ClapModel

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-unfused")

>>> input_text = ["Sound of a dog", "Sound of vacuum cleaner"]

>>> inputs = processor(text=input_text, audio=audio_sample, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)
>>> logits_per_audio = outputs.logits_per_audio  # this is the audio-text similarity score
>>> probs = logits_per_audio.softmax(dim=-1)  # we can take the softmax to get the label probabilities
```

#### get_text_features[[transformers.ClapModel.get_text_features]]

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

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1467)

**参数：**

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

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

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

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

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。
- **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
>>> import torch
>>> from transformers import AutoTokenizer, ClapModel

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["the sound of a cat", "the sound of a dog"], padding=True, return_tensors="pt")
>>> with torch.inference_mode():
...     text_features = model.get_text_features(**inputs)
```

#### get_audio_features[[transformers.ClapModel.get_audio_features]]

```python
get_audio_features(input_features: Tensor, is_longer: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1501)

**参数：**

input_features (`torch.Tensor`，形状为 `(batch_size, sequence_length, feature_dim)`)：与输入音频特征对应的张量。可以使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 获取音频特征。有关详细信息，请参阅 `ClapFeatureExtractor.__call__()`（[ClapProcessor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapProcessor) 使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 处理音频）。

is_longer (`torch.Tensor`，形状为 `(batch_size, 1)`，*可选*)：音频片段是否长于 `max_length`。如果为 `True`，将启用特征融合以增强特征。

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

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

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

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。
- **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
>>> import torch
>>> from transformers import AutoFeatureExtractor, ClapModel

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused")
>>> random_audio = torch.rand((16_000))

>>> inputs = feature_extractor(random_audio, return_tensors="pt")
>>> with torch.inference_mode():
...     audio_features = model.get_audio_features(**inputs)
```

## ClapTextModel[[transformers.ClapTextModel]]

#### transformers.ClapTextModel[[transformers.ClapTextModel]]

```python
transformers.ClapTextModel(config: ClapTextConfig, add_pooling_layer = True)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1346)

**参数：**

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

add_pooling_layer (`bool`，*可选*，默认为 `True`)：是否添加池化层

该模型既可以作为编码器（仅使用自注意力）运行，也可以作为解码器运行。在后一种情况下，会在自注意力层之间添加一层交叉注意力，其架构遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 *Attention is all you need*_ 中描述的架构。

要使模型作为解码器运行，需要在初始化时将配置中的 `is_decoder` 参数设置为 `True`。若要在 Seq2Seq 模型中使用，则需要在初始化时将 `is_decoder` 参数和 `add_cross_attention` 均设置为 `True`；此时，前向传播的输入中需要包含 `encoder_hidden_states`。

.. _*注意力就是你所需要的一切*：https://huggingface.co/papers/1706.03762

该模型继承自 [PreTrainedModel](/docs/transformers/main/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.ClapTextModel.forward]]

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

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1376)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引取自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

position_ids （`torch.Tensor`，形状为 `(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` 索引转换为对应的向量，这将非常有用。

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

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

[ClapTextModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapTextModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。
- **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 后的注意力权重，用于在自注意力头中计算加权平均值。

## ClapTextModelWithProjection[[transformers.ClapTextModelWithProjection]]

#### transformers.ClapTextModelWithProjection[[transformers.ClapTextModelWithProjection]]

```python
transformers.ClapTextModelWithProjection(config: ClapTextConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1623)

**参数：**

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

带有投影层的 Clap 模型（在池化输出之上添加一个线性层）。

该模型继承自 [PreTrainedModel](/docs/transformers/main/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.ClapTextModelWithProjection.forward]]

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

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1644)

**参数：**

input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/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)

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

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

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

[ClapTextModelWithProjection](/docs/transformers/main/zh/model_doc/clap#transformers.ClapTextModelWithProjection) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **text_embeds**（形状为 `(batch_size, output_dim)` 的 `torch.Tensor`，*可选*，当模型以 `with_projection=True` 初始化时返回）-- 通过对 pooler_output 应用投影层获得的文本嵌入。
- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型最后一层输出的隐藏状态序列。
- **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 AutoTokenizer, ClapTextModelWithProjection

>>> model = ClapTextModelWithProjection.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["a sound of a cat", "a sound of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds
```

## ClapAudioModel[[transformers.ClapAudioModel]]

#### transformers.ClapAudioModel[[transformers.ClapAudioModel]]

```python
transformers.ClapAudioModel(config: ClapAudioConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1282)

#### forward[[transformers.ClapAudioModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, is_longer: typing.Optional[torch.BoolTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1296)

**参数：**

input_features (`torch.Tensor`，形状为 `(batch_size, sequence_length, feature_dim)`，*可选*) : 与输入音频特征对应的张量。可以使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 获取音频特征。有关详细信息，请参阅 `ClapFeatureExtractor.__call__()`（[ClapProcessor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapProcessor) 使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 处理音频）。

is_longer (`torch.Tensor`，形状为 `(batch_size, 1)`，*可选*)：音频片段是否长于 `max_length`。如果为 `True`，将启用特征融合以增强特征。

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

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

[ClapAudioModel](/docs/transformers/main/zh/model_doc/clap#transformers.ClapAudioModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。
- **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 datasets import load_dataset
>>> from transformers import AutoProcessor, ClapAudioModel

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapAudioModel.from_pretrained("laion/clap-htsat-fused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-fused")

>>> inputs = processor(audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
```

## ClapAudioModelWithProjection[[transformers.ClapAudioModelWithProjection]]

#### transformers.ClapAudioModelWithProjection[[transformers.ClapAudioModelWithProjection]]

```python
transformers.ClapAudioModelWithProjection(config: ClapAudioConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1685)

**参数：**

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

带有投影层的 Clap 模型（在池化输出之上添加一个线性层）。

该模型继承自 [PreTrainedModel](/docs/transformers/main/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.ClapAudioModelWithProjection.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, is_longer: typing.Optional[torch.BoolTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clap/modeling_clap.py#L1700)

**参数：**

input_features (`torch.Tensor`，形状为 `(batch_size, sequence_length, feature_dim)`，*可选*) : 与输入音频特征对应的张量。可以使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 获取音频特征。有关详细信息，请参阅 `ClapFeatureExtractor.__call__()`（[ClapProcessor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapProcessor) 使用 [ClapFeatureExtractor](/docs/transformers/main/zh/model_doc/clap#transformers.ClapFeatureExtractor) 处理音频）。

is_longer (`torch.Tensor`，形状为 `(batch_size, 1)`，*可选*)：音频片段是否长于 `max_length`。如果为 `True`，将启用特征融合以增强特征。

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

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

[ClapAudioModelWithProjection](/docs/transformers/main/zh/model_doc/clap#transformers.ClapAudioModelWithProjection) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **audio_embeds**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 通过对 pooler_output 应用投影层获得的音频嵌入。
- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型最后一层输出的隐藏状态序列。
- **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 datasets import load_dataset
>>> from transformers import ClapAudioModelWithProjection, ClapProcessor

>>> model = ClapAudioModelWithProjection.from_pretrained("laion/clap-htsat-fused")
>>> processor = ClapProcessor.from_pretrained("laion/clap-htsat-fused")

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> inputs = processor(audio=audio_sample, return_tensors="pt")
>>> outputs = model(**inputs)
>>> audio_embeds = outputs.audio_embeds
```