# Stable Audio

Stable Audio a été proposé dans [Stable Audio Open](https://huggingface.co/papers/2407.14358) par Zach Evans et al. . Il prend en entrée un prompt texte et prédit l'échantillon de son ou de musique correspondant.

Stable Audio Open génère de l’audio stéréo de longueur variable (jusqu’à 47 s) à 44,1 kHz à partir de prompts texte. Il se compose de trois composants : un autoencodeur qui compresse les formes d’onde en une longueur de séquence gérable, un embedding de texte basé sur T5 pour le conditionnement par le texte, et un modèle de diffusion basé sur un transformer (DiT) qui opère dans l’espace latent de l’autoencodeur.

Stable Audio est entraîné sur un corpus d'environ 48k enregistrements audio, dont environ 47k proviennent de Freesound et le reste du Free Music Archive (FMA). Tous les fichiers audio sont sous licence CC0, CC BY ou CC Sampling+. Ces données sont utilisées pour entraîner l'autoencodeur et le DiT.

L’abstract de l’article est le suivant : *Les modèles génératifs ouverts sont d’une importance vitale pour la communauté, car ils permettent le fine-tuning et servent de références lors de la présentation de nouveaux modèles. Cependant, la plupart des modèles actuels de texte vers audio sont privés et ne sont pas accessibles aux artistes et aux chercheurs pour qu’ils puissent s’en servir comme base. Nous décrivons ici l’architecture et le processus d’entraînement d’un nouveau modèle de texte vers audio à poids ouverts, entraîné avec des données Creative Commons. Notre évaluation montre que les performances du modèle sont compétitives par rapport à l’état de l’art sur diverses métriques. Notamment, les résultats FDopenl3 rapportés (mesurant le réalisme des générations) mettent en évidence son potentiel pour la synthèse sonore stéréo de haute qualité à 44,1 kHz.*

Ce pipeline a été contribué par [Yoach Lacombe](https://huggingface.co/ylacombe). La base de code originale peut être trouvée sur [Stability-AI/stable-audio-tools](https://github.com/Stability-AI/stable-audio-tools).

## Astuces

Lors de la construction d'un prompt, gardez à l'esprit :

* Les entrées de prompt descriptives fonctionnent le mieux ; utilisez des adjectifs pour décrire le son (par exemple, « high quality » ou « clear ») et faites en sorte que le prompt soit contextuellement spécifique lorsque c’est possible (par exemple, « melodic techno with a fast beat and synths » fonctionne mieux que « techno »).
* L'utilisation d'un *prompt négatif* peut considérablement améliorer la qualité de l'audio généré. Essayez d'utiliser un prompt négatif de « low quality, average quality ».

Pendant l'inférence :

* La _qualité_ de l'échantillon audio généré peut être contrôlée par l'argument `num_inference_steps` ; un nombre de pas plus élevé produit un audio de meilleure qualité au prix d'une inférence plus lente.
* Plusieurs formes d’onde peuvent être générées en une seule fois : définissez `num_waveforms_per_prompt` sur une valeur supérieure à 1 pour l’activer. Un score automatique sera effectué entre les formes d’onde générées et le texte de la requête, et les audios seront classés du meilleur au moins bon en conséquence.

## Quantification

La quantification aide à réduire les besoins en mémoire des très grands modèles en stockant les poids du modèle dans un type de données de précision inférieure. Cependant, la quantification peut avoir un impact variable sur la qualité de la vidéo selon le modèle vidéo.

Reportez-vous à l’aperçu de la [Quantization](../../quantization/overview) pour en savoir plus sur les backends de quantification pris en charge et sur la sélection d’un backend de quantification adapté à votre cas d’usage. L’exemple ci-dessous montre comment charger un [StableAudioPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_audio#diffusers.StableAudioPipeline) quantifié pour l’inférence avec bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, StableAudioDiTModel, StableAudioPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = StableAudioDiTModel.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = StableAudioPipeline.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "The sound of a hammer hitting a wooden surface."
negative_prompt = "Low quality."
audio = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=200,
    audio_end_in_s=10.0,
    num_waveforms_per_prompt=3,
    generator=generator,
).audios

output = audio[0].T.float().cpu().numpy()
sf.write("hammer.wav", output, pipeline.vae.sampling_rate)
```

## StableAudioPipeline[[diffusers.StableAudioPipeline]]

#### diffusers.StableAudioPipeline[[diffusers.StableAudioPipeline]]

```python
diffusers.StableAudioPipeline(vae: AutoencoderOobleck, text_encoder: T5EncoderModel, projection_model: StableAudioProjectionModel, tokenizer: T5Tokenizer, transformer: StableAudioDiTModel, scheduler: EDMDPMSolverMultistepScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py#L78)

**Paramètres :**

vae ([AutoencoderOobleck](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_oobleck#diffusers.AutoencoderOobleck)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

text_encoder ([T5EncoderModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5EncoderModel)) : encodeur de texte figé. StableAudio utilise l’encodeur de [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google-t5/t5-base](https://huggingface.co/google-t5/t5-base).

projection_model (`StableAudioProjectionModel`) : un modèle entraîné utilisé pour projeter linéairement les états cachés du modèle d’encodeur de texte ainsi que les secondes de début et de fin. Les états cachés projetés de l’encodeur et les secondes conditionnelles sont concaténés pour former l’entrée du modèle transformer.

tokenizer ([T5Tokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5Tokenizer)) : Tokenizer pour tokeniser le texte destiné à l'encodeur de texte figé.

transformer ([StableAudioDiTModel](/docs/diffusers/v0.43.0/fr/api/models/stable_audio_transformer#diffusers.StableAudioDiTModel)) : un `StableAudioDiTModel` pour débruyer les latents audio encodés.

scheduler ([EDMDPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/edm_multistep_dpm_solver#diffusers.EDMDPMSolverMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents audio encodés.

Pipeline pour la génération de texte en audio utilisant StableAudio.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

#### __appel__[[diffusers.StableAudioPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, audio_end_in_s: float | None = None, audio_start_in_s: float | None = 0.0, num_inference_steps: int = 100, guidance_scale: float = 7.0, negative_prompt: str | list[str] | None = None, num_waveforms_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, initial_audio_waveforms: typing.Optional[torch.Tensor] = None, initial_audio_sampling_rate: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int | None = 1, output_type: str | None = 'pt')
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py#L462)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération audio. S'il n'est pas défini, vous devez passer `prompt_embeds`.

audio_end_in_s (`float`, *facultatif*, valeur par défaut 47.55) : Index de fin de l'audio en secondes.

audio_start_in_s (`float`, *facultatif*, valeur par défaut 0) : Index de début de l'audio en secondes.

num_inference_steps (`int`, *facultatif*, valeur par défaut 100) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à un audio de meilleure qualité, au prix d'une inférence plus lente.

guidance_scale (`float`, *facultatif*, valeur par défaut 7.0) : Une valeur d'échelle de guidage plus élevée encourage le modèle à générer un audio étroitement lié au `prompt` texte, au détriment de la qualité sonore. L'échelle de guidage est activée lorsque `guidance_scale > 1`.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider ce qu'il ne faut pas inclure dans la génération audio. S'il n'est pas défini, vous devez passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n'est pas utilisée (`guidance_scale < 1`).

num_waveforms_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de formes d'onde à générer par invite.

eta (`float`, *facultatif*, valeur par défaut 0.0) : Correspond au paramètre eta (η) de l'article [DDIM](https://huggingface.co/papers/2010.02502). S'applique uniquement au [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler) et est ignoré par les autres planificateurs.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération audio. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du `generator` aléatoire fourni.

initial_audio_waveforms (`torch.Tensor`, *facultatif*) : Formes d'onde audio initiales facultatives à utiliser comme forme d'onde audio initiale pour la génération. Doit être de forme `(batch_size, num_channels, audio_length)` ou `(batch_size, audio_length)`, où `batch_size` correspond au nombre de prompts transmis au modèle.

initial_audio_sampling_rate (`int`, *facultatif*) : Taux d'échantillonnage des `initial_audio_waveforms`, si elles sont fournies. Doit être identique à celui du modèle.

prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte précalculés issus du modèle encodeur de texte. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront calculés à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatifs précalculés par le modèle encodeur de texte. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera calculé à partir de l'argument d'entrée `negative_prompt`.

attention_mask (`torch.LongTensor`, *facultatif*) : Masque d'attention précalculé à appliquer aux `prompt_embeds`. S'il n'est pas fourni, le masque d'attention sera calculé à partir de l'argument d'entrée `prompt`.

negative_attention_mask (`torch.LongTensor`, *facultatif*) : Masque d'attention précalculé à appliquer aux `negative_text_audio_duration_embeds`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) plutôt qu'un simple tuple.

callback (`Callable`, *facultatif*) : une fonction appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction est appelée avec les arguments suivants : `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *facultatif*, valeur par défaut 1) : La fréquence à laquelle la fonction `callback` est appelée. Si non spécifié, le callback est appelé à chaque étape.

output_type (`str`, *facultatif*, par défaut `"pt"`) : Le format de sortie de l'audio généré. Choisissez entre `"np"` pour retourner un `np.ndarray` NumPy ou `"pt"` pour retourner un objet `torch.Tensor` PyTorch. Définissez sur `"latent"` pour retourner la sortie du modèle de diffusion latente (LDM).

**Retourne :** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant l’audio généré.

La fonction d'appel du pipeline pour la génération.

Exemples :
```py
>>> import scipy
>>> import torch
>>> import soundfile as sf
>>> from diffusers import StableAudioPipeline

>>> repo_id = "stabilityai/stable-audio-open-1.0"
>>> pipe = StableAudioPipeline.from_pretrained(repo_id, torch_dtype=torch.float16)
>>> pipe = pipe.to("cuda")

>>> # define the prompts
>>> prompt = "The sound of a hammer hitting a wooden surface."
>>> negative_prompt = "Low quality."

>>> # set the seed for generator
>>> generator = torch.Generator("cuda").manual_seed(0)

>>> # run the generation
>>> audio = pipe(
...     prompt,
...     negative_prompt=negative_prompt,
...     num_inference_steps=200,
...     audio_end_in_s=10.0,
...     num_waveforms_per_prompt=3,
...     generator=generator,
... ).audios

>>> output = audio[0].T.float().cpu().numpy()
>>> sf.write("hammer.wav", output, pipe.vae.sampling_rate)
```