# CLVP

## Aperçu

Le modèle CLVP (Contrastive Language-Voice Pretrained Transformer) a été proposé dans [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) par James Betker.

L'abstract de l'article est le suivant :

*Ces dernières années, le domaine de la génération d’images a été révolutionné par l’application des transformeurs autorégressifs et des DDPM. Ces approches modélisent le processus de génération d’images comme un processus probabiliste par étapes et exploitent de grandes quantités de calcul et de données pour apprendre la distribution des images. Cette méthodologie d’amélioration des performances ne doit pas être limitée aux images. Cet article décrit une manière d’appliquer les avancées du domaine de la génération d’images à la synthèse vocale. Le résultat est TorToise, un système expressif de synthèse vocale multi-voix.*

Ce modèle a été contribué par [Susnato Dhar](https://huggingface.co/susnato). Le code d'origine est disponible [ici](https://github.com/neonbjb/tortoise-tts).

## Conseils d'utilisation

1. CLVP est une partie intégrante du modèle Tortoise TTS.
2. CLVP peut être utilisé pour comparer différents candidats de parole générés avec le texte fourni, et les meilleurs jetons de parole sont transmis au modèle de diffusion.
3. L'utilisation de la méthode `ClvpModelForConditionalGeneration.generate()` est fortement recommandée pour l'utilisation de tortoise.
4. Notez que le modèle CLVP s'attend à ce que l'audio soit échantillonné à 22,05 kHz, contrairement à d'autres modèles audio qui s'attendent à 16 kHz.

## Explication succincte

- Le [ClvpTokenizer](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpTokenizer) tokenise l'entrée texte, et le [ClvpFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor) extrait le log mel-spectrogramme de l'audio souhaité.
- `ClvpConditioningEncoder` prend ces jetons de texte et ces représentations audio et les convertit en plongements conditionnés par le texte et l’audio.
- Le [ClvpForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpForCausalLM) utilise ces embeddings pour générer plusieurs candidats vocaux.
- Chaque candidat vocal est transmis à l’encodeur vocal ([ClvpEncoder](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpEncoder)) qui le convertit en une représentation vectorielle, et l’encodeur texte ([ClvpEncoder](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpEncoder)) convertit les jetons de texte dans le même espace latent.
- Enfin, nous comparons chaque vecteur de parole au vecteur de texte pour déterminer quel vecteur de parole est le plus similaire au vecteur de texte.
- `ClvpModelForConditionalGeneration.generate()` regroupe toute la logique décrite ci-dessus dans une seule méthode.

Exemple :

```python
import datasets

from transformers import ClvpModelForConditionalGeneration, ClvpProcessor

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

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

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

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

## ClvpConfig[[transformers.ClvpConfig]]

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

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

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

**Paramètres :**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

speech_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser l'encodeur vocal CLVP.

decoder_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [ClvpDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpDecoderConfig).

projection_dim (`int`, *facultatif*, valeur par défaut `768`) : Dimension des couches de projection du texte et de la vision.

logit_scale_init_value (`float`, *facultatif*, valeur par défaut `2.6592`) : La valeur initiale du paramètre *logit_scale*.

initializer_factor (`float`, *facultatif*, par défaut `1.0`) : Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

Il s'agit de la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import ClvpConfig, ClvpModelForConditionalGeneration

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

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

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

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

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

>>> config = ClvpConfig(config_text, config_speech, decoder_config)
```

## ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

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

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

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

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `256`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, par défaut `1536`) : Dimension des représentations MLP.

projection_dim (`int`, *facultatif*, valeur par défaut `768`) : Dimension des couches de projection du texte et de la vision.

num_hidden_layers (`int`, *facultatif*, par défaut `20`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

use_rotary_embedding (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser rotary_embedding ou non.

use_attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches Query, Key et Value lors de l'auto-attention.

summary_type (`str`, *facultatif*, valeur par défaut `"mean"`) : Stratégie à utiliser pour obtenir pooler_output à partir de last_hidden_state. `"last"`, `"first"`, `"mean"` et `"cls_index"` sont pris en charge.

initializer_factor (`float`, *facultatif*, par défaut `1.0`) : Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

bos_token_id (`int`, *facultatif*, valeur par défaut `255`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `0`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import ClvpEncoderConfig, ClvpEncoder

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

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

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

## ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

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

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

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

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `8194`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `608`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

max_text_tokens (`int`, *facultatif*, par défaut 404) : La longueur maximale de séquence des jetons de texte avec laquelle ce modèle pourrait être utilisé. Similaire à `n_positions` dans `GPT2Config`.

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `30`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

n_inner (`int`, *facultatif*) : Dimensionnalité des couches feed-forward internes. `None` la définit à 4 fois `hidden_size`.

num_mel_attn_blocks (`int`, *facultatif*, valeur par défaut : 6) : Indique le nombre de couches d'auto-attention dans `ClvpConditioningEncoder`.

activation_function (`str`, *facultatif*, par défaut `gelu_new`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

resid_pdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

embd_pdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout pour les embeddings.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention.

layer_norm_epsilon (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

summary_type (`string`, *facultatif*, par défaut `"cls_index"`) : Argument utilisé lors de la résumation de séquence. Doit être l'une des options suivantes : - `"last"` : Prend l'état caché du dernier jeton (comme XLNet). - `"first"` : Prend l'état caché du premier jeton (comme BERT). - `"mean"` : Prend la moyenne des états cachés de tous les jetons. - `"cls_index"` : Fournit un Tensor indiquant la position du jeton de classification (comme GPT/GPT-2). - `"attn"` : Non implémenté pour le moment, utilise l'attention multi-têtes.

summary_use_proj (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une projection après l'extraction du vecteur.

summary_activation (`str`, *facultatif*) : Passez `"tanh"` pour appliquer une activation tanh à la sortie ; toute autre valeur ne déclenchera aucune activation.

summary_proj_to_labels (`bool`, *facultatif*, par défaut `True`) : Indique si les sorties de la projection doivent avoir `config.num_labels` ou `config.hidden_size` classes.

summary_first_dropout (`float`, *facultatif*, valeur par défaut 0,1) : Le taux de dropout à utiliser après la projection et l'activation.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

bos_token_id (`int`, *facultatif*, valeur par défaut `8192`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `8193`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

feature_size (`int`, *facultatif*, valeur par défaut 80) : La dimension des caractéristiques mel extraites. Cette valeur est utilisée dans `ClvpConditioningEncoder`.

use_attention_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les couches Query, Key et Value lors de l'auto-attention.

initializer_factor (`float`, *facultatif*, par défaut `1.0`) : Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

decoder_fixing_codes (`list`, *facultatif*, valeur par défaut `[83, 45, 45, 248]`) : ces valeurs sont utilisées dans la méthode `fix_speech_decoder_output` pour corriger les sorties générées par le décodeur.

add_cross_attention (`bool`, *facultatif*, par défaut `False`) : Indique si des couches d'attention croisée doivent être ajoutées au modèle.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import ClvpDecoderConfig, ClvpDecoder

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

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

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

## ClvpTokenizer[[transformers.ClvpTokenizer]]

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

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

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

**Paramètres :**

vocab_file (`str`) : Chemin vers le fichier de vocabulaire.

merges_file (`str`) : Chemin vers le fichier de fusions.

errors (`str`, *facultatif*, valeur par défaut `"replace"`) : Paradigme à suivre lors du décodage des octets en UTF-8. Consultez [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) pour plus d'informations.

unk_token (`str`, *facultatif*, valeur par défaut `"[UNK]"`) : le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

bos_token (`str`, *facultatif*, par défaut `"<|endoftext|>"`) : Jeton de début de séquence.

eos_token (`str`, *facultatif*, valeur par défaut `"[STOP]"`) : Jeton de fin de séquence.

pad_token (`str`, *facultatif*, valeur par défaut `"[STOP]"`) : Jeton de bourrage de la séquence.

add_prefix_space (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer CLVP détecte le début des mots grâce à l'espace qui les précède).

Construit un tokenizer CLVP. Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding) au niveau des octets.

Ce tokenizer a été entraîné à traiter les espaces comme des parties des jetons (un peu comme sentencepiece), de sorte qu'un mot sera

être encodé différemment selon qu'il se trouve au début de la phrase (sans espace) ou non :

```python
>>> from transformers import ClvpTokenizer

>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]

>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]
```

Vous pouvez contourner ce comportement en passant `add_prefix_space=True` lors de l’instanciation de ce tokenizer ou lors de son appel sur un texte, mais comme le modèle n’a pas été pré-entraîné de cette manière, cela pourrait entraîner une baisse des performances.

Lorsqu'il est utilisé avec `is_split_into_words=True`, ce tokeniseur ajoute un espace avant chaque mot (y compris le premier).

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

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

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

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

**Paramètres :**

save_directory (`str`) : Le répertoire dans lequel enregistrer le vocabulaire.

filename_prefix (`str`, *facultatif*) : Préfixe facultatif à ajouter au nom des fichiers enregistrés.

**Retourne :** `tuple[str, ...]`

Chemin des fichiers enregistrés, ou tuple vide si aucun fichier n'a été enregistré.

Implémentation par défaut pour les motifs courants de sauvegarde du vocabulaire. Enregistre self.encoder/self.vocab au format JSON, éventuellement avec self.bpe_ranks en tant que fusions. Retourne un tuple vide si aucun vocabulaire n'existe.

Écrasez cette méthode si votre tokenizer nécessite une logique de sauvegarde personnalisée (par exemple, des modèles SentencePiece, plusieurs fichiers de vocabulaire ou des formats de fichiers spéciaux).

## ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

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

```python
transformers.ClvpFeatureExtractor(feature_size = 80, sampling_rate = 22050, default_audio_length = 6, hop_length = 256, chunk_length = 30, n_fft = 1024, padding_value = 0.0, mel_norms = None, return_attention_mask = False, **kwargs)
```

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

**Paramètres :**

feature_size (`int`, *facultatif*, valeur par défaut 80) : La dimension des caractéristiques des fonctionnalités extraites.

sampling_rate (`int`, *facultatif*, valeur par défaut 22050) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

default_audio_length (`int`, *facultatif*, valeur par défaut : 6) : La durée par défaut de l'audio brut, en secondes. Si `max_length` n'est pas défini lors de l'appel de `__call__`, il est automatiquement défini à default_audio_length * `self.sampling_rate`.

hop_length (`int`, *facultatif*, valeur par défaut 256) : Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel.

chunk_length (`int`, *facultatif*, valeur par défaut : 30) : Nombre maximal de blocs de `sampling_rate` échantillons utilisés pour rober et compléter les séquences audio plus longues ou plus courtes.

n_fft (`int`, *facultatif*, valeur par défaut 1024) : Taille de la transformée de Fourier.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : Valeur de bourrage utilisée pour bourrer l'audio. Doit correspondre aux silences.

mel_norms (`list` de longueur `feature_size`, *facultatif*) : Si `mel_norms` est fourni, il sera utilisé pour normaliser les spectrogrammes log-mel le long de chaque filtre mel.

return_attention_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention sera retourné. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

Construit un extracteur de fonctionnalités CLVP.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait des caractéristiques de spectrogramme log-mel à partir de la parole brute à l'aide d'une implémentation numpy personnalisée de la `Short Time Fourier Transform`, qui doit correspondre à l'équivalent `torch.stft` de pytorch.

#### __appel__[[transformers.ClvpFeatureExtractor.__call__]]

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

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

**Paramètres :**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Doit être un audio mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.

sampling_rate (`int`, *facultatif*) : Le taux d'échantillonnage auquel l'entrée `raw_speech` a été échantillonnée. Il est fortement recommandé de passer `sampling_rate` lors de l'appel forward afin d'éviter les erreurs silencieuses et de permettre le pipeline de reconnaissance automatique de la parole.

truncation (`bool`, *facultatif*, par défaut `True`) : Active la troncature pour couper les séquences d'entrée plus longues que *max_length* à *max_length*.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient de longueurs de séquence multiples de 128.

return_attention_mask (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : La valeur utilisée pour remplir les valeurs / vecteurs de bourrage.

max_length (`int`, *facultatif*) : La longueur maximale des entrées.

`ClvpFeatureExtractor` est utilisé pour extraire diverses propriétés spécifiques à la voix, telles que le ton et la hauteur de la voix, la vitesse d’élocution, et même des défauts de parole comme un bégaiement ou une articulation approximative, à partir d’un échantillon de voix ou de `raw_speech`.

D'abord, le signal audio est complété ou tronqué de manière à obtenir une forme d'onde d'une durée de `self.default_audio_length` secondes, puis le spectrogramme log-mel est extrait de celle-ci.

## ClvpProcessor[[transformers.ClvpProcessor]]

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

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

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

**Paramètres :**

feature_extractor (`ClvpFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`ClvpTokenizer`) : le tokenizer est une entrée obligatoire.

Construit un ClvpProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

[ClvpProcessor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpProcessor) offre toutes les fonctionnalités de [ClvpFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor) et de [ClvpTokenizer](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpTokenizer). Consultez [~ClvpFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor) et [~ClvpTokenizer](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpTokenizer) pour plus d’informations.

#### __appel__[[transformers.ClvpProcessor.__call__]]

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

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

**Paramètres :**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

audio (``) : l'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

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

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

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

Cette méthode transmet tous ses arguments à [decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

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

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

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

Cette méthode transmet tous ses arguments à [batch_decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

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

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

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

**Paramètres :**

config ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle CLVP composite avec un encodeur de texte, un encodeur de parole et un modèle de décodeur de parole.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [ClvpFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor). Voir [ClvpFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__) pour plus de détails ([ClvpProcessor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpProcessor) utilise [ClvpFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpFeatureExtractor) pour le traitement des audios).

conditioning_encoder_inputs_embeds (`torch.Tensor`, *facultatif*) : inputs_embeds pour `ClvpConditioningEncoder`. Peut être utilisé à la place de `input_ids`.

text_encoder_inputs_embeds (`torch.Tensor`, *facultatif*) : inputs_embeds pour le modèle d'encodeur de texte, transmis à la place de `input_ids`.

attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

return_loss (`bool`, *facultatif*) : Indique s'il faut ou non retourner la perte contrastive.

**Retourne :** `ClvpOutput` ou `tuple(torch.Tensor)`

Un `ClvpOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et les entrées.

La méthode forward de [ClvpModelForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpModelForConditionalGeneration) surcharge la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `return_loss` est `True`) -- Perte contrastive pour la similarité parole-texte.
- **speech_ids** (`torch.LongTensor`, *facultatif*) -- speech_ids (ou candidats vocaux) générés par le modèle `ClvpForCausalLM`.
- **logits_per_speech** (`torch.Tensor` de forme `(speech_batch_size, text_batch_size)`) -- Les scores de produit scalaire normalisé entre `speech_embeds` et `text_embeds`. Cela représente les scores de similarité entre le discours et le texte.
- **logits_per_text** (`torch.Tensor` de forme `(text_batch_size, speech_batch_size)`) -- Les scores de produit scalaire normalisé entre `text_embeds` et `speech_embeds`. Cela représente les scores de similarité texte-parole.
- **text_embeds** (`torch.Tensor` de forme `(batch_size, output_dim`) -- Les embeddings de texte obtenus en appliquant la couche de projection à la sortie agrégée du modèle encodeur de texte.
- **speech_embeds** (`torch.Tensor` de forme `(batch_size, output_dim`) -- Les embeddings de parole obtenus en appliquant la couche de projection à la sortie agrégée du modèle encodeur de parole.
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- La sortie agrégée de `last_hidden_state` du modèle encodeur de texte.
- **speech_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- La sortie agrégée de `last_hidden_state` du modèle d'encodeur audio.
- **decoder_hidden_states** (`torch.Tensor`, *facultatif*) -- Les états cachés du modèle décodeur.
- **text_encoder_hidden_states** (`torch.Tensor`, *facultatif*) -- Les états cachés du modèle d'encodeur de texte.
- **speech_encoder_hidden_states** (`torch.Tensor`, *facultatif*) -- Les états cachés du modèle d'encodeur vocal.

Exemples :

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

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

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

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

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

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

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

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

**Paramètres :**

input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Jetons de texte en entrée. Traités à partir du [ClvpTokenizer](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpTokenizer).

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de jetons de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

generation_config (`~generation.GenerationConfig`, *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à generate qui correspondent aux attributs de `generation_config` les remplaceront. Si `generation_config` n'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle `generation_config.json`, s'il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), dont la documentation doit être consultée pour paramétrer la génération.

pad_to_max_mel_tokens (`int`, *facultatif*) : Remplit les speech_ids générés avec la valeur spécifiée. Cela permet d'implémenter la même logique que dans le dépôt officiel, lien : https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 et de s'assurer que les logits sont identiques. Cela n'affecte pas la qualité de la génération, il est donc déconseillé de l'utiliser car il est moins efficace.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés des modèles de décodeur, d'encodeur de texte et d'encodeur de parole.

**Retourne :** `ClvpOutput` ou tuple

Un `ClvpOutput` (si `return_dict_in_generate=True` ou lorsque `config.return_dict_in_generate=True`) ou un tuple.

Méthode de génération pour `ClvpModelForConditionalGeneration`, cette méthode appelle la méthode `generate` de `ClvpForCausalLM` puis utilise les `speech_ids` générés pour traiter `text_embeds` et `speech_embeds` à l'aide de `ClvpEncoder`.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

text_encoder_inputs_embeds (`torch.Tensor`, *facultatif*) : inputs_embeds pour le modèle d'encodeur de texte, transmis à la place de `input_ids`.

attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

**Retourne :** `ClvpEncoderOutput` ou `tuple(torch.Tensor)`

Un `ClvpEncoderOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et les entrées.

Cette méthode peut être utilisée pour extraire text_embeds à partir d'un texte. Les embeddings de texte sont obtenus en appliquant la couche de projection à la sortie agrégée du modèle d'encodeur de texte CLVP.

- **embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque le modèle est initialisé avec `with_projection=True`) -- Les embeddings obtenus en appliquant la couche de projection au pooler_output.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- L'état caché de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- Sortie agrégée de `last_hidden_state`.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

```python
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

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

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

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

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

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

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

**Paramètres :**

speech_ids (`torch.LongTensor` de forme `(batch_size, num_speech_ids)`, *facultatif*) : Jetons de parole. Le bourrage sera ignoré par défaut si vous le fournissez. Si speech_ids sont fournis, input_ids et input_features seront automatiquement ignorés.

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Jetons du texte d'entrée. Traités à partir du [ClvpTokenizer](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpTokenizer). Si speech_ids n'est pas fourni, input_ids et input_features seront utilisés.

conditioning_encoder_inputs_embeds (`torch.Tensor`, *facultatif*) : inputs_embeds pour `ClvpConditioningEncoder`. Peut être utilisé à la place de `input_ids`.

attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de jetons de remplissage de la parole. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

generation_config (`GenerationConfig`, *facultatif*) : configuration de génération pour contrôler la génération de speech_ids si elles ne sont pas fournies.

**Retourne :** `torch.Tensor` de forme `(batch_size, output_dim)`

Les embeddings de parole obtenus en appliquant la couche de projection à la sortie agrégée du modèle CLVP Speech.

Cette méthode peut être utilisée pour extraire speech_embeds. Les embeddings vocaux sont obtenus en appliquant le modèle vocal sur speech_ids. Si speech_ids n'est pas présent mais que input_ids et input_features sont tous les deux fournis, le modèle décodeur sera d'abord utilisé pour générer speech_ids, puis le modèle vocal sera appliqué.

Exemples :

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

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

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

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

## ClvpForCausalLM[[transformers.ClvpForCausalLM]]

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

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

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

**Paramètres :**

config ([ClvpDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpDecoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle de décodeur CLVP avec une tête de modélisation de langage au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le modélisation du langage. Notez que les étiquettes **sont décalées** à l'intérieur du modèle, c'est-à-dire que vous pouvez définir `labels = input_ids` Les indices sont sélectionnés dans `[-100, 0, ..., config.vocab_size]` Toutes les étiquettes définies sur `-100` sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans `[0, ..., config.vocab_size]`

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou `tuple(torch.Tensor)`

Un [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et des entrées.

La méthode forward de [ClvpForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpForCausalLM) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids des attentions croisées après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.

## ClvpModel[[transformers.ClvpModel]]

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

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

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

**Paramètres :**

config ([ClvpDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpDecoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Clvp brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et les entrées.

La méthode forward du [ClvpModel](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` et `config.add_cross_attention=True` sont passés ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

## ClvpEncoder[[transformers.ClvpEncoder]]

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

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

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

**Paramètres :**

config : ClvpConfig

Encodeur Transformer composé de `config.num_hidden_layers` couches d'auto-attention. Chaque couche est une `ClvpEncoderLayer`.

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

inputs_embeds (`torch.LongTensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

**Retourne :** `ClvpEncoderOutput` ou `tuple(torch.Tensor)`

Un `ClvpEncoderOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et les entrées.

La méthode forward de [ClvpEncoder](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpEncoder) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque le modèle est initialisé avec `with_projection=True`) -- Les embeddings obtenus en appliquant la couche de projection au pooler_output.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- L'état caché de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- Sortie agrégée de `last_hidden_state`.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## ClvpDecoder[[transformers.ClvpDecoder]]

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

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

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

Décodeur Transformer composé de *config.num_hidden_layers* couches. Chaque couche est une `ClvpDecoderLayer`

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

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ClvpConfig](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpConfig)) et les entrées.

La méthode forward de [ClvpDecoder](/docs/transformers/v5.23.0/fr/model_doc/clvp#transformers.ClvpDecoder) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` et `config.add_cross_attention=True` sont passés ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

