# CLAP

[CLAP (Contrastive Language-Audio Pretraining)](https://huggingface.co/papers/2211.06687) é um modelo multimodal que combina dados de áudio com descrições em linguagem natural por meio de aprendizado contrastivo.

Ele incorpora fusão de recursos e aumento de palavras-chave para legendas para processar entradas de áudio de comprimento variável e melhorar o desempenho. O CLAP não requer dados de treinamento específicos para a tarefa e pode aprender representações de áudio significativas por meio de linguagem natural.

Você pode encontrar todos os checkpoints originais do CLAP na coleção [CLAP](https://huggingface.co/collections/laion/clap-contrastive-language-audio-pretraining-65415c0b18373b607262a490).

> [!TIP]
> Este modelo foi contribuído por [ybelkada](https://huggingface.co/ybelkada) e [ArthurZ](https://huggingface.co/ArthurZ).
>
> Clique nos modelos CLAP na barra lateral à direita para ver mais exemplos de como aplicar o CLAP em diferentes tarefas de recuperação e classificação de áudio.

O exemplo abaixo demonstra como extrair embeddings de texto com a classe [AutoModel](/docs/transformers/main/pt/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)
```

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

**Parâmetros:**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio.

logit_scale_init_value (`float`, *opcional*, padrão `14.285714285714285`) : O valor inicial do parâmetro *logit_scale*.

projection_dim (`int`, *opcional*, padrão `512`) : Dimensionalidade das camadas de projeção de texto e visão.

projection_hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação usada pelo projetor multimodal.

initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização).

Esta é a classe de configuração para armazenar a configuração de um ClapModel. Ela é usada para instanciar um modelo Clap de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `50265`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.

max_position_embeddings (`int`, *opcional*, padrão `514`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado.

type_vocab_size (`int`, *opcional*, padrão `1`) : O tamanho do vocabulário dos `token_type_ids`.

initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização).

layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada.

projection_dim (`int`, *opcional*, padrão `512`) : Dimensionalidade das camadas de projeção de texto e visão.

pad_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para preenchimento no vocabulário.

bos_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

projection_hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação usada pelo projetor multimodal.

Esta é a classe de configuração para armazenar a configuração de um ClapModel. Ela é usada para instanciar um modelo Clap de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

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

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

**Parâmetros:**

window_size (`int`, *opcional*, padrão 8) : Tamanho da imagem do espectrograma

num_mel_bins (`int`, *opcional*, padrão `64`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

spec_size (`int`, *opcional*, padrão 256) : Tamanho de entrada desejado do espectrograma suportado pelo modelo. Pode ser diferente da saída do `ClapFeatureExtractor`, caso em que os recursos de entrada serão redimensionados. Corresponde ao `image_size` dos modelos de áudio.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `4`) : O tamanho (resolução) de cada patch.

patch_stride (`list`, *opcional*, padrão `[4, 4]`) : Passo do patch para o espectrograma de áudio

num_classes (`int`, *opcional*, padrão 527) : Número de classes usadas para o treinamento da head

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

projection_dim (`int`, *opcional*, padrão `512`) : Dimensionalidade das camadas de projeção de texto e visão.

depths (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(2, 2, 6, 2)`) : Profundidade de cada camada no Transformer.

num_attention_heads (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(4, 8, 16, 32)`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

enable_fusion (`bool`, *opcional*, padrão `False`) : Se a fusão de patches deve ser habilitada ou não. Esta é a principal contribuição dos autores e deve proporcionar os melhores resultados.

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler.

fusion_type (`[type]`, *opcional*) : Tipo de fusão usado para a fusão de patches.

patch_embed_input_channels (`int`, *opcional*, padrão 1) : Número de canais usados para o espectrograma de entrada

flatten_patch_embeds (`bool`, *opcional*, padrão `True`) : Se as incorporações de patch devem ser achatadas ou não

patch_embeds_hidden_size (`int`, *opcional*, padrão 96) : Tamanho oculto dos embeddings de patch. É usado como o número de canais de saída.

enable_patch_layer_norm (`bool`, *opcional*, padrão `True`) : Se a normalização de camada deve ser habilitada para os embeddings de patch

drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

mlp_ratio (`float`, *opcional*, padrão `4.0`) : Razão entre a dimensão oculta do MLP e a dimensão de incorporação.

aff_block_r (`int`, *opcional*, padrão 4) : downsize_ratio usado no bloco AudioFF

num_hidden_layers (`int`, *opcional*, padrão `4`) : Número de camadas ocultas no decodificador do Transformer.

projection_hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação usada pelo projetor multimodal.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização).

Esta é a classe de configuração para armazenar a configuração de um ClapModel. Ela é usada para instanciar um modelo Clap de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do [laion/clap-htsat-fused](https://huggingface.co/laion/clap-htsat-fused)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 64) : A dimensão dos recursos dos espectrogramas de Mel extraídos. Isso corresponde ao número de filtros de Mel (`n_mels`).

sampling_rate (`int`, *opcional*, padrão 48000) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz). Isso serve apenas para alertar os usuários caso o áudio fornecido ao extrator de recursos não tenha a mesma taxa de amostragem.

hop_length (`int`,*opcional*, padrão 480) : Comprimento das janelas sobrepostas para a STFT usada para obter o Espectrograma Mel. O áudio será dividido em `frames` menores, com um passo de `hop_length` entre cada frame.

max_length_s (`int`, *opcional*, padrão 10) : O comprimento máximo de entrada do modelo, em segundos. Isso é usado para aplicar padding ao áudio.

fft_window_size (`int`, *opcional*, padrão 1024) : Tamanho da janela (em amostras) sobre a qual a transformada de Fourier é aplicada. Isso controla a resolução de frequência do espectrograma. 400 significa que a transformada de Fourier é calculada em janelas de 400 amostras.

padding_value (`float`, *opcional*, padrão 0.0) : Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.

return_attention_mask (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ou não retornar as máscaras de atenção correspondentes à entrada.

frequency_min (`float`, *opcional*, padrão 0) : A menor frequência de interesse. A STFT não será calculada para valores abaixo deste.

frequency_max (`float`, *opcional*, padrão 14000) : A frequência máxima de interesse. A STFT não será calculada para valores acima disso.

top_db (`float`, *opcional*) : O valor máximo em decibéis usado para converter o espectrograma mel para a escala logarítmica. Para mais detalhes, consulte a função `audio_utils.power_to_db`

truncation (`str`, *opcional*, padrão `"fusion"`) : Padrão de truncamento para entradas de áudio longas. Dois padrões estão disponíveis: - `fusion` usará `_random_mel_fusion`, que empilha 3 recortes aleatórios do espectrograma mel e uma versão subamostrada do espectrograma mel inteiro. Se `config.fusion` estiver definido como True, áudios mais curtos também precisarão retornar 4 mels, que serão apenas uma cópia do mel original obtido do áudio com padding. - `rand_trunc` selecionará um recorte aleatório do espectrograma mel.

padding (`str`, *opcional*, padrão `"repeatpad"`) : Padrão de preenchimento para entradas de áudio mais curtas. Três padrões foram implementados originalmente: - `repeatpad`: o áudio é repetido e, em seguida, preenchido para se ajustar ao `max_length`. - `repeat`: o áudio é repetido e, em seguida, cortado para se ajustar ao `max_length` - `pad`: o áudio é preenchido.

Constrói um extrator de recursos CLAP.

Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos.

Esta classe extrai recursos de banco de filtros mel a partir de fala bruta usando uma implementação customizada em numpy da *Short Time Fourier Transform* (STFT), que deve corresponder ao equivalente `torch.stft` do pytorch.

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

```python
to_dict()
```

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

**Retorna:** `dict[str, Any]`

Dicionário de todos os atributos que compõem esta instância de configuração, exceto os bancos de filtros mel, que não precisam ser salvos ou impressos, pois são longos demais.

Serializa esta instância em um dicionário Python.

## ClapProcessor[[transformers.ClapProcessor]]

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

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

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

**Parâmetros:**

feature_extractor (`ClapFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`RobertaTokenizer`) : O tokenizer é uma entrada obrigatória.

Constrói um ClapProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

[ClapProcessor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapProcessor) oferece todas as funcionalidades de [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) e [RobertaTokenizer](/docs/transformers/main/pt/model_doc/led#transformers.RobertaTokenizer). Consulte [~ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) e [~RobertaTokenizer](/docs/transformers/main/pt/model_doc/led#transformers.RobertaTokenizer) para mais informações.

#### __call__[[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'>)
```

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

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote.

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]]]`, *opcional*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

## ClapModel[[transformers.ClapModel]]

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

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

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

**Parâmetros:**

config ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Clap puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor). Veja `ClapFeatureExtractor.__call__()` para mais detalhes ([ClapProcessor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapProcessor) usa [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) para processar áudios).

is_longer (`torch.Tensor`, de forma `(batch_size, 1)`, *opcional*) : Se o clipe de áudio é mais longo que `max_length`. Se `True`, uma fusão de recursos será habilitada para aprimorar os recursos.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

return_loss (`bool`, *opcional*) : Se deve ou não retornar a perda contrastiva.

**Retorna:** `ClapOutput` ou `tuple(torch.Tensor)`

Um `ClapOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

O método forward do [ClapModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `return_loss` é `True`) -- Perda contrastiva para similaridade áudio-texto.
- **logits_per_audio** (`torch.Tensor` de forma `(audio_batch_size, text_batch_size)`) -- As pontuações de produto escalar normalizado entre `audio_embeds` e `text_embeds`. Isso representa as pontuações de similaridade entre áudio e texto.
- **logits_per_text** (`torch.Tensor` de forma `(text_batch_size, audio_batch_size)`) -- As pontuações de produto escalar normalizado entre `text_embeds` e `audio_embeds`. Isso representa as pontuações de similaridade entre texto e áudio.
- **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- As embeddings de texto obtidas ao aplicar a camada de projeção à saída agregada de [ClapTextModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextModel).
- **audio_embeds** (`torch.Tensor` de forma `(batch_size, output_dim`) -- Os embeddings de áudio obtidos ao aplicar a camada de projeção à saída agregada de [ClapAudioModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapAudioModel).
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída do [ClapTextModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextModel).
- **audio_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída do [ClapAudioModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapAudioModel).

Exemplos:

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

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

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obter detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor). Consulte `ClapFeatureExtractor.__call__()` para detalhes ([ClapProcessor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapProcessor) usa [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) para processar áudios).

is_longer (`torch.Tensor`, de forma `(batch_size, 1)`, *opcional*) : Se o clipe de áudio é mais longo que `max_length`. Se `True`, uma fusão de recursos será habilitada para aprimorar os recursos.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

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

**Parâmetros:**

config ([ClapTextConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling

O modelo pode se comportar como um codificador (com apenas autoatenção) e também como um decodificador, no qual uma camada de atenção cruzada é adicionada entre as camadas de autoatenção, seguindo a arquitetura descrita em *Attention is all you need*_ por Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser e Illia Polosukhin.

Para se comportar como um decoder, o modelo precisa ser inicializado com o argumento `is_decoder` da configuração definido como `True`. Para ser usado em um modelo Seq2Seq, o modelo precisa ser inicializado com os argumentos `is_decoder` e `add_cross_attention` definidos como `True`; nesse caso, espera-se que `encoder_hidden_states` seja fornecido como entrada para a passagem de forward.

.. _*Atenção é tudo o que você precisa*: https://huggingface.co/papers/1706.03762

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`:  - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

O método forward do [ClapTextModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## ClapTextModelWithProjection[[transformers.ClapTextModelWithProjection]]

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

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

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

**Parâmetros:**

config ([ClapTextConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Clap com uma camada de projeção no topo (uma camada linear no topo da saída agregada).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

**Retorna:** `ClapTextModelOutput` ou `tuple(torch.Tensor)`

Um `ClapTextModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

O método forward do [ClapTextModelWithProjection](/docs/transformers/main/pt/model_doc/clap#transformers.ClapTextModelWithProjection) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim)` *opcional* retornado quando o modelo é inicializado com `with_projection=True`) -- Os embeddings de texto obtidos ao aplicar a camada de projeção ao pooler_output.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do modelo.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

[Origem](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'>)
```

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor). Veja `ClapFeatureExtractor.__call__()` para mais detalhes ([ClapProcessor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapProcessor) usa [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) para processar áudios).

is_longer (`torch.Tensor`, de forma `(batch_size, 1)`, *opcional*) : Se o clipe de áudio é mais longo que `max_length`. Se `True`, uma fusão de recursos será habilitada para aprimorar os recursos.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

O método forward do [ClapAudioModel](/docs/transformers/main/pt/model_doc/clap#transformers.ClapAudioModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

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

**Parâmetros:**

config ([ClapAudioConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapAudioConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Clap com uma camada de projeção no topo (uma camada linear no topo da saída agregada).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor). Veja `ClapFeatureExtractor.__call__()` para mais detalhes ([ClapProcessor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapProcessor) usa [ClapFeatureExtractor](/docs/transformers/main/pt/model_doc/clap#transformers.ClapFeatureExtractor) para processar áudios).

is_longer (`torch.Tensor`, de forma `(batch_size, 1)`, *opcional*) : Se o clipe de áudio é mais longo que `max_length`. Se `True`, uma fusão de recursos será habilitada para aprimorar os recursos.

**Retorna:** `ClapAudioModelOutput` ou `tuple(torch.Tensor)`

Um `ClapAudioModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([ClapConfig](/docs/transformers/main/pt/model_doc/clap#transformers.ClapConfig)) e das entradas.

O método forward do [ClapAudioModelWithProjection](/docs/transformers/main/pt/model_doc/clap#transformers.ClapAudioModelWithProjection) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **audio_embeds** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Os embeddings de áudio obtidos ao aplicar a camada de projeção ao pooler_output.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de hidden-states na saída da última camada do modelo.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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