Stable Audio

Stable Audio a été proposé dans Stable Audio Open 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 de 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. La base de code originale peut être trouvée sur 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 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 quantifié pour l’inférence avec bitsandbytes.

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

classe diffusers.StableAudioPipeline

< source >

( vae: AutoencoderOoblecktext_encoder: T5EncoderModelprojection_model: StableAudioProjectionModeltokenizer: T5Tokenizertransformer: StableAudioDiTModelscheduler: EDMDPMSolverMultistepScheduler )

Paramètres

vae (AutoencoderOobleck) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (T5EncoderModel) — Encodeur de texte figé. StableAudio utilise l’encodeur de T5, plus précisément la variante 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) — Jetoniseur pour tokeniser le texte destiné à l'encodeur de texte figé.
transformer (StableAudioDiTModel) — Un StableAudioDiTModel pour débruisser les latents audio encodés.
scheduler (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. 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.).

call

< source >

( prompt: str | list[str] = Noneaudio_end_in_s: float | None = Noneaudio_start_in_s: float | None = 0.0num_inference_steps: int = 100guidance_scale: float = 7.0negative_prompt: str | list[str] | None = Nonenum_waveforms_per_prompt: int | None = 1eta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneinitial_audio_waveforms: typing.Optional[torch.Tensor] = Noneinitial_audio_sampling_rate: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonenegative_attention_mask: typing.Optional[torch.LongTensor] = Nonereturn_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int | None = 1output_type: str | None = 'pt' ) → StableDiffusionPipelineOutput or tuple

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, par défaut 47.55) — Index de fin de l'audio en secondes.
audio_start_in_s (float, facultatif, 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 de guidance scale plus élevée incite le modèle à générer un audio étroitement lié au texte prompt, au détriment de la qualité sonore. Le guidance scale est activé lorsque guidance_scale > 1.
negative_prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider ce qui ne doit pas être inclus 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. Ne s'applique qu'au DDIMScheduler et est ignoré par les autres planificateurs.
generator (torch.Generator ou list[torch.Generator], facultatif) — Un torch.Generator 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 par le 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 ex. 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 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 renvoyer un tableau NumPy np.ndarray ou "pt" pour renvoyer un objet PyTorch torch.Tensor. Définissez sur "latent" pour renvoyer la sortie du modèle de diffusion latente (LDM).

Retourne

StableDiffusionPipelineOutput ou tuple

Si return_dict est True, 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 :

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

Update on GitHub