# Bark

## Aperçu

[Bark](https://huggingface.co/suno/bark) est un modèle de synthèse vocale basé sur des transformers, proposé par Suno AI dans [suno-ai/bark](https://github.com/suno-ai/bark).

Bark est composé de 4 modèles principaux :

- [BarkSemanticModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkSemanticModel) (également appelé modèle « text ») : un modèle transformer causal auto-régressif qui prend en entrée du texte tokenisé et prédit des jetons sémantiques de texte capturant le sens du texte.
- [BarkCoarseModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCoarseModel) (également appelé modèle « coarse acoustics ») : un transformer autorégressif causal qui prend en entrée les résultats du modèle [BarkSemanticModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkSemanticModel). Il vise à prédire les deux premiers codebooks audio nécessaires pour EnCodec.
- [BarkFineModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkFineModel) (le modèle « fine acoustics »), cette fois-ci un transformateur auto-encodeur non causal, qui prédit itérativement les derniers codebooks à partir de la somme des embeddings des codebooks précédents.
- Après avoir prédit tous les canaux du codebook à partir du [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel), Bark l’utilise pour décoder le tableau de sortie audio.

Il convient de noter que chacun des trois premiers modules peut prendre en charge des embeddings de locuteur conditionnels afin de conditionner le son de sortie en fonction d'une voix prédéfinie spécifique.

Ce modèle a été contribué par [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe) et [Sanchit Gandhi (sanchit-gandhi)](https://github.com/sanchit-gandhi). Le code d’origine est disponible [ici](https://github.com/suno-ai/bark).

### Optimiser Bark

Bark peut être optimisé avec seulement quelques lignes de code supplémentaires, ce qui **réduit considérablement son empreinte mémoire** et **accélère l'inférence**.

#### Utilisation de la demi-précision

Vous pouvez accélérer l'inférence et réduire l'empreinte mémoire de 50 % simplement en chargeant le modèle en demi-précision.

```python
from transformers import BarkModel

model = BarkModel.from_pretrained("suno/bark-small", device_map="auto")
```

#### Utilisation du déchargement sur CPU

Comme mentionné ci-dessus, Bark est composé de 4 sous-modèles, qui sont appelés séquentiellement lors de la génération audio. Autrement dit, pendant qu'un sous-modèle est utilisé, les autres sous-modèles sont inactifs.

Si vous utilisez un GPU CUDA ou un XPU Intel, une solution simple pour bénéficier d’une réduction de 80 % de l’empreinte mémoire consiste à décharger les sous-modèles de l’appareil vers le CPU lorsqu’ils sont inactifs. Cette opération est appelée *CPU offloading*. Vous pouvez l’utiliser avec une seule ligne de code comme suit :

```python
model.enable_cpu_offload()
```

Notez que 🤗 Accelerate doit être installé avant d'utiliser cette fonctionnalité. [Voici comment l'installer.](https://huggingface.co/docs/accelerate/basic_tutorials/install)

#### Utilisation de Flash Attention 2

Flash Attention 2 est une version encore plus rapide et optimisée de l'optimisation précédente.

##### Installation

Tout d'abord, vérifiez si votre matériel est compatible avec Flash Attention 2. La liste la plus récente du matériel compatible se trouve dans la [documentation officielle](https://github.com/Dao-AILab/flash-attention#installation-and-features). Ensuite, [installez](https://github.com/Dao-AILab/flash-attention#installation-and-features) la dernière version de Flash Attention 2 :

```bash
pip install -U flash-attn --no-build-isolation
```

##### Utilisation

Pour charger un modèle en utilisant Flash Attention 2, nous pouvons passer le drapeau `attn_implementation="flash_attention_2"` à [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained). Nous chargerons également le modèle en demi-précision (par exemple `torch.float16`), car cela entraîne une dégradation quasi nulle de la qualité audio, mais une consommation mémoire nettement réduite et une inférence plus rapide :

```python
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")
```

##### Comparaison des performances

Le diagramme suivant montre la latence de l’implémentation native de l’attention (sans optimisation) par rapport à Flash Attention 2. Dans tous les cas, nous générons 400 jetons sémantiques sur un GPU A100 de 40 Go avec PyTorch 2.1 :

Pour situer les choses, sur une NVIDIA A100 et en générant 400 jetons sémantiques avec une taille de lot de 16, vous pouvez obtenir un [débit](https://huggingface.co/blog/optimizing-bark#throughput) 17 fois supérieur et être encore 2 secondes plus rapide que la génération de phrases une par une avec l’implémentation native du modèle. Autrement dit, tous les échantillons seront générés 17 fois plus vite.

#### Combinaison des techniques d’optimisation

Vous pouvez combiner les techniques d’optimisation et utiliser le déchargement sur CPU, la demi-précision et Flash Attention 2 simultanément.

```python
from transformers import BarkModel

# load in fp16 and use Flash Attention 2
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")

# enable CPU offload
model.enable_cpu_offload()
```

En savoir plus sur les techniques d’optimisation de l’inférence [ici](https://huggingface.co/docs/transformers/perf_infer_gpu_one).

### Conseils d'utilisation

Suno propose une bibliothèque de préréglages vocaux dans plusieurs langues [ici](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c). Ces préréglages sont également téléversés sur le hub [ici](https://huggingface.co/suno/bark-small/tree/main/speaker_embeddings) ou [ici](https://huggingface.co/suno/bark/tree/main/speaker_embeddings).

```python
from transformers import AutoProcessor, BarkModel

processor = AutoProcessor.from_pretrained("suno/bark")
model = BarkModel.from_pretrained("suno/bark", device_map="auto")

voice_preset = "v2/en_speaker_6"

inputs = processor("Hello, my dog is cute", voice_preset=voice_preset)

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

Bark peut générer une parole **multilingue** très réaliste ainsi que d'autres types d'audio, y compris de la musique, des bruits de fond et des effets sonores simples.

```python
# Multilingual speech - simplified Chinese
inputs = processor("惊人的！我会说中文")

# Multilingual speech - French - let's use a voice_preset as well
inputs = processor("Incroyable! Je peux générer du son.", voice_preset="fr_speaker_5")

# Bark can also generate music. You can help it out by adding music notes around your lyrics.
inputs = processor("♪ Hello, my dog is cute ♪")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

Le modèle peut également produire des **communications non verbales** comme des rires, des soupirs et des pleurs.

```python
# Adding non-speech cues to the input text
inputs = processor("Hello uh [clears throat], my dog is cute [laughter]")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

Pour enregistrer l'audio, il suffit de récupérer le taux d'échantillonnage depuis la configuration du modèle et d'utiliser quelques utilitaires de scipy :

```python
from scipy.io.wavfile import write as write_wav

# save audio to disk, but first take the sample rate from the model config
sample_rate = model.generation_config.sample_rate
write_wav("bark_generation.wav", sample_rate, audio_array)
```

## BarkConfig[[transformers.BarkConfig]]

#### transformers.BarkConfig[[transformers.BarkConfig]]

```python
transformers.BarkConfig(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, semantic_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, coarse_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fine_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, codec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L188)

**Paramètres :**

semantic_config ([BarkSemanticConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkSemanticConfig), *facultatif*) : Configuration du sous-modèle sémantique sous-jacent.

coarse_acoustics_config ([BarkCoarseConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCoarseConfig), *facultatif*) : Configuration du sous-modèle acoustique grossier sous-jacent.

fine_acoustics_config ([BarkFineConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkFineConfig), *facultatif*) : Configuration du sous-modèle acoustique fin sous-jacent.

codec_config ([AutoConfig](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoConfig), *facultatif*) : Configuration du sous-modèle de codec sous-jacent.

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 (
...     BarkSemanticConfig,
...     BarkCoarseConfig,
...     BarkFineConfig,
...     BarkModel,
...     BarkConfig,
...     AutoConfig,
... )

>>> # Initializing Bark sub-modules configurations.
>>> semantic_config = BarkSemanticConfig()
>>> coarse_acoustics_config = BarkCoarseConfig()
>>> fine_acoustics_config = BarkFineConfig()
>>> codec_config = AutoConfig.from_pretrained("facebook/encodec_24khz")

>>> # Initializing a Bark module style configuration
>>> configuration = BarkConfig(
...     semantic_config, coarse_acoustics_config, fine_acoustics_config, codec_config
... )

>>> # Initializing a model (with random weights)
>>> model = BarkModel(configuration)

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

## BarkProcessor[[transformers.BarkProcessor]]

#### transformers.BarkProcessor[[transformers.BarkProcessor]]

```python
transformers.BarkProcessor(tokenizer, speaker_embeddings = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L35)

**Paramètres :**

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

speaker_embeddings (`dict[dict[str]]`, *facultatif*) : Dictionnaire imbriqué facultatif d'embeddings de locuteurs. Le premier niveau contient les noms de préréglages vocaux (par ex. `"en_speaker_4"`). Le second niveau contient les embeddings `"semantic_prompt"`, `"coarse_prompt"` et `"fine_prompt"`. Les valeurs correspondent au chemin du `np.ndarray` correspondant. Voir [ici](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c) pour la liste des `voice_preset_names`.

Construit un BarkProcessor qui encapsule un tokenizer dans un processeur unique.

[BarkProcessor](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkProcessor) propose toutes les fonctionnalités de [BertTokenizer](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.BertTokenizer). Consultez la documentation de [~BertTokenizer](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.BertTokenizer) pour plus d’informations.

#### __appel__[[transformers.BarkProcessor.__call__]]

```python
__call__(text = None, voice_preset = None, return_tensors = 'pt', max_length = 256, add_special_tokens = False, return_attention_mask = True, return_token_type_ids = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L296)

**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.

voice_preset (`str`, `dict[np.ndarray]`) : Le préréglage vocal, c’est-à-dire les embeddings de locuteur. Il peut s’agir soit d’un nom de voice_preset valide, par exemple `"en_speaker_1"`, soit directement d’un dictionnaire d’embeddings `np.ndarray` pour chaque sous-modèle de `Bark`. Il peut également s’agir d’un nom de fichier valide d’un préréglage vocal local unique au format `.npz` contenant les clés `"semantic_prompt"`, `"coarse_prompt"` et `"fine_prompt"`.

return_tensors (``, defaults to `pt`) : If set, will return tensors of a particular framework. Acceptable values are:  - `'pt'`: Return PyTorch `torch.Tensor` objects. - `'np'`: Return NumPy `np.ndarray` objects.

max_length (`int`, par défaut `256`) : Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

add_special_tokens (`bool`, par défaut `False`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette option utilise la fonction sous-jacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons `bos` ou `eos`.

return_attention_mask (`bool`, par défaut `True`) : Indique s'il faut renvoyer le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est renvoyé selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_token_type_ids (`bool`, par défaut `False`) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

**Retourne :** [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding)

Un objet [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) contenant la sortie du `tokenizer`. Si un préréglage vocal est fourni, l'objet retourné inclura une clé `"history_prompt"` contenant un [BatchFeature](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.BatchFeature), c'est-à-dire le préréglage vocal avec le bon type de tenseurs.

#### from_pretrained[[transformers.BarkProcessor.from_pretrained]]

```python
from_pretrained(pretrained_processor_name_or_path, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L55)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Peut être l'un des éléments suivants :  - une chaîne de caractères, l'*identifiant de modèle* d'un [BarkProcessor](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkProcessor) pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co. - un chemin vers un *répertoire* contenant un processeur enregistré à l'aide de la méthode [save_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkProcessor.save_pretrained), par exemple `./my_model_directory/`.

speaker_embeddings_dict_path (`str`, *facultatif*, valeur par défaut `"speaker_embeddings_path.json"`) : Le nom du fichier `.json` contenant le dictionnaire speaker_embeddings situé dans `pretrained_model_name_or_path`. Si `None`, aucun speaker_embeddings n'est chargé.

- ****kwargs** : Arguments supplémentaires passés à `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instanciez un processeur Bark associé à un modèle pré-entraîné.

#### save_pretrained[[transformers.BarkProcessor.save_pretrained]]

```python
save_pretrained(save_directory, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', speaker_embeddings_directory = 'speaker_embeddings', push_to_hub: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/processing_bark.py#L121)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : répertoire où les fichiers du tokenizer et les embeddings des locuteurs seront enregistrés (le répertoire sera créé s'il n'existe pas).

speaker_embeddings_dict_path (`str`, *facultatif*, par défaut `"speaker_embeddings_path.json"`) : Le nom du fichier `.json` qui contiendra le dictionnaire de chemins imbriqués speaker_embeddings, s'il existe, et qui sera situé dans `pretrained_model_name_or_path/speaker_embeddings_directory`.

speaker_embeddings_directory (`str`, *facultatif*, par défaut `"speaker_embeddings/"`) : Nom du dossier dans lequel les tableaux speaker_embeddings seront enregistrés.

push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

kwargs : Arguments supplémentaires de type mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Enregistre les attributs de ce processeur (tokeniseur...) dans le répertoire spécifié afin qu'il puisse être rechargé à l'aide de la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkProcessor.from_pretrained).

## BarkModel[[transformers.BarkModel]]

#### transformers.BarkModel[[transformers.BarkModel]]

```python
transformers.BarkModel(config: BarkConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1250)

**Paramètres :**

config ([BarkConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkConfig)) : 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 Bark complet, un modèle de synthèse vocale composé de 4 sous-modèles :
- [BarkSemanticModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkSemanticModel) (également appelé modèle « text ») : un modèle transformer auto-régressif causal qui
prend en entrée un texte tokenisé et prédit des jetons de texte sémantiques qui capturent le sens du texte.
- [BarkCoarseModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCoarseModel) (également appelé modèle « acoustique grossière »), lui aussi un transformateur autorégressif causal,
qui prend en entrée les résultats du dernier modèle. Il vise à régresser les deux premiers codebooks audio nécessaires à `encodec`.
- [BarkFineModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkFineModel) (le modèle « fine acoustics »), cette fois-ci un transformateur auto-encodeur non causal, qui itérativement
prédit les derniers codebooks à partir de la somme des embeddings des codebooks précédents.
- après avoir prédit tous les canaux du codebook à partir du [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel), Bark l’utilise pour décoder l’audio de sortie
array.

Il convient de noter que chacun des trois premiers modules peut prendre en charge des embeddings de locuteur conditionnels afin de conditionner le son de sortie en fonction d'une voix prédéfinie spécifique.

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.

#### generate[[transformers.BarkModel.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, history_prompt: dict[str, torch.Tensor] | None = None, return_output_lengths: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1354)

**Paramètres :**

input_ids (`Optional[torch.Tensor]` de forme (batch_size, seq_len), *facultatif*) : Identifiants d'entrée. Seront tronqués à 256 jetons. Notez que les audios de sortie seront aussi longs que la génération la plus longue du lot.

history_prompt (`Optional[dict[str,torch.Tensor]]`, *facultatif*) : Prompt de locuteur `Bark` facultatif. Veuillez noter que, pour l'instant, ce modèle n'accepte qu'un seul prompt de locuteur par lot.

kwargs (*facultatif*) : Dictionnaire restant des arguments par mot-clé. Les arguments par mot-clé sont de deux types :  - Sans préfixe, ils sont transmis en tant que `**kwargs` à la méthode `generate` de chaque sous-modèle. - Avec un préfixe *semantic_*, *coarse_*, *fine_*, ils sont transmis respectivement à la méthode `generate` des modèles sémantique, grossier et fin. Ils ont la priorité sur les mots-clés sans préfixe.  Cela signifie que vous pouvez, par exemple, spécifier une stratégie de génération pour tous les sous-modèles sauf un.

return_output_lengths (`bool`, *facultatif*) : Indique s'il faut ou non retourner les longueurs des formes d'onde. Utile lors du traitement par lots.

**Retourne :** `By default`

- **audio_waveform** (`torch.Tensor` de forme (batch_size, seq_len)) : Forme d'onde audio générée.
Lorsque `return_output_lengths=True` : renvoie un tuple composé de :
- **audio_waveform** (`torch.Tensor` de forme (batch_size, seq_len)) : Forme d'onde audio générée.
- **output_lengths** (`torch.Tensor` de forme (batch_size)) : la longueur de chaque forme d'onde du lot

Génère de l’audio à partir d’un prompt d’entrée et d’un prompt de locuteur `Bark` supplémentaire facultatif.

Exemple :

```python
>>> from transformers import AutoProcessor, BarkModel

>>> processor = AutoProcessor.from_pretrained("suno/bark-small")
>>> model = BarkModel.from_pretrained("suno/bark-small")

>>> # To add a voice preset, you can pass `voice_preset` to `BarkProcessor.__call__(...)`
>>> voice_preset = "v2/en_speaker_6"

>>> inputs = processor("Hello, my dog is cute, I need him in my life", voice_preset=voice_preset)

>>> audio_array = model.generate(**inputs, semantic_max_new_tokens=100)
>>> audio_array = audio_array.cpu().numpy().squeeze()
```

#### enable_cpu_offload[[transformers.BarkModel.enable_cpu_offload]]

```python
enable_cpu_offload(accelerator_id: int | None = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1292)

**Paramètres :**

accelerator_id (`int`, *facultatif*, valeur par défaut 0) : identifiant de l'accélérateur sur lequel les sous-modèles seront chargés et déchargés.

Décharge tous les sous-modèles sur le CPU à l'aide de accelerate, réduisant ainsi l'utilisation de la mémoire avec un impact minimal sur les performances. Cette méthode déplace un sous-modèle entier à la fois vers l'accélérateur lorsqu'il est utilisé, et le sous-modèle reste sur l'accélérateur jusqu'à l'exécution du sous-modèle suivant.

## BarkSemanticModel[[transformers.BarkSemanticModel]]

#### transformers.BarkSemanticModel[[transformers.BarkSemanticModel]]

```python
transformers.BarkSemanticModel(config: BarkSubModelConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L516)

**Paramètres :**

config (`BarkSubModelConfig`) : 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.

Modèle sémantique (ou textuel) de Bark. Il partage la même architecture que le modèle grossier. C'est un modèle autorégressif de type GPT-2 doté d'une tête de modélisation de langage.

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.BarkSemanticModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Paramètres :**

input_ids (`torch.Tensor` 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)

position_ids (`torch.Tensor` 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 position IDs ?](../glossary#position-ids)

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

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

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 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 ([BarkConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkConfig)) et les entrées.

La méthode forward du [BarkCausalModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCausalModel) 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).
- **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) 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.

## BarkCoarseModel[[transformers.BarkCoarseModel]]

#### transformers.BarkCoarseModel[[transformers.BarkCoarseModel]]

```python
transformers.BarkCoarseModel(config: BarkSubModelConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L632)

**Paramètres :**

config (`BarkSubModelConfig`) : 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.

Modèle d’acoustique grossière de Bark. Il partage la même architecture que le modèle sémantique (ou de texte). Il s’agit d’un modèle autorégressif de type GPT-2, doté d’une tête de modélisation de langage.

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.BarkCoarseModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Paramètres :**

input_ids (`torch.Tensor` 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)

position_ids (`torch.Tensor` 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 position IDs ?](../glossary#position-ids)

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

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

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 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 ([BarkConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkConfig)) et les entrées.

La méthode forward du [BarkCausalModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCausalModel) 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).
- **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) 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.

## BarkFineModel[[transformers.BarkFineModel]]

#### transformers.BarkFineModel[[transformers.BarkFineModel]]

```python
transformers.BarkFineModel(config: BarkFineConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L856)

**Paramètres :**

config ([BarkFineConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkFineConfig)) : 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.

Modèle d’acoustique fine de Bark. Il s’agit d’un modèle non causal de type GPT doté de `config.n_codes_total` couches d’incorporation et de têtes de modélisation du langage, une pour chaque codebook.

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.BarkFineModel.forward]]

```python
forward(codebook_idx: int, input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L983)

**Paramètres :**

codebook_idx (`int`) : Index du codebook qui sera prédit.

input_ids (`torch.Tensor` 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)

position_ids (`torch.Tensor` 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 position IDs ?](../glossary#position-ids)

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : PAS ENCORE IMPLÉMENTÉ.

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.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [MaskedLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 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 ([BarkConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkConfig)) et les entrées.

La méthode forward du modèle [BarkFineModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkFineModel) 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 de langage masquée (MLM).
- **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.

## BarkCausalModel[[transformers.BarkCausalModel]]

#### transformers.BarkCausalModel[[transformers.BarkCausalModel]]

```python
transformers.BarkCausalModel(config: BarkSubModelConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L351)

#### forward[[transformers.BarkCausalModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Paramètres :**

input_ids (`torch.Tensor` 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)

position_ids (`torch.Tensor` 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 position IDs ?](../glossary#position-ids)

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

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

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 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 ([BarkConfig](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkConfig)) et les entrées.

La méthode forward du [BarkCausalModel](/docs/transformers/v5.23.0/fr/model_doc/bark#transformers.BarkCausalModel) 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).
- **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) 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.

## BarkCoarseConfig[[transformers.BarkCoarseConfig]]

#### transformers.BarkCoarseConfig[[transformers.BarkCoarseConfig]]

```python
transformers.BarkCoarseConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L105)

**Paramètres :**

block_size (`int`, *facultatif*, valeur par défaut 1024) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).

input_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par les `inputs_ids` passés lors de l'appel de `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

output_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par : `output_ids` lors du passage en avant d'un `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

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

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

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

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

bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par 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.

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkCoarseConfig, BarkCoarseModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkCoarseConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkCoarseModel(configuration)

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

## BarkFineConfig[[transformers.BarkFineConfig]]

#### transformers.BarkFineConfig[[transformers.BarkFineConfig]]

```python
transformers.BarkFineConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True, tie_word_embeddings: bool = True, n_codes_total: int = 8, n_codes_given: int = 1)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L142)

**Paramètres :**

block_size (`int`, *facultatif*, valeur par défaut 1024) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).

input_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par les `inputs_ids` passés lors de l'appel de `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

output_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par : `output_ids` lors du passage en avant d'un `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

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

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

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

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

bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par 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.

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.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

n_codes_total (`int`, *facultatif*, valeur par défaut : 8) : Nombre total de codebooks audio prédits. Utilisé dans le sous-modèle d'acoustique fine.

n_codes_given (`int`, *facultatif*, valeur par défaut 1) : Le nombre de codebooks audio prédits dans le sous-modèle acoustique grossier. Utilisé dans les sous-modèles acoustiques.

Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkFineConfig, BarkFineModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkFineConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkFineModel(configuration)

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

## BarkSemanticConfig[[transformers.BarkSemanticConfig]]

#### transformers.BarkSemanticConfig[[transformers.BarkSemanticConfig]]

```python
transformers.BarkSemanticConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/configuration_bark.py#L68)

**Paramètres :**

block_size (`int`, *facultatif*, valeur par défaut 1024) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).

input_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par les `inputs_ids` passés lors de l'appel de `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

output_vocab_size (`int`, *facultatif*, valeur par défaut 10_048) : Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par : `output_ids` lors du passage en avant d'un `{model}`. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné.

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

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

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

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

bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par 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.

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkSemanticConfig, BarkSemanticModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkSemanticConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkSemanticModel(configuration)

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

