# AudioLDM 2 AudioLDM 2 a été proposé dans [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734) par Haohe Liu et al. AudioLDM 2 prend en entrée un prompt texte et prédit l'audio correspondant. Il peut générer des effets sonores conditionnés par le texte, de la parole humaine et de la musique. Inspiré de [Stable Diffusion](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/overview), AudioLDM 2 est un _modèle de diffusion latente (LDM)_ de texte vers audio qui apprend des représentations audio continues à partir d'embeddings de texte. Deux modèles d'encodeur de texte sont utilisés pour calculer les embeddings de texte à partir d'une invite d'entrée : la branche texte de [CLAP](https://huggingface.co/docs/transformers/main/en/model_doc/clap) et l'encodeur de [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5). Ces embeddings de texte sont ensuite projetés dans un espace d'embedding partagé par un [AudioLDM2ProjectionModel](https://huggingface.co/docs/diffusers/main/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel). Un [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2) _modèle de langage (LM)_ est utilisé pour prédire de manière auto-régressive huit nouveaux vecteurs d'embedding, conditionnellement aux embeddings projetés de CLAP et Flan-T5. Les vecteurs d'embedding générés et les embeddings de texte Flan-T5 sont utilisés comme conditionnement par attention croisée dans le LDM. Le [UNet](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel) d'AudioLDM 2 est unique en ce sens qu'il prend **deux** embeddings d'attention croisée, par opposition à un seul conditionnement par attention croisée, comme dans la plupart des autres LDM. L’abstract de l’article est le suivant : *Bien que la génération audio présente des points communs entre les différents types d'audio, tels que la parole, la musique et les effets sonores, la conception de modèles pour chaque type nécessite une réflexion approfondie sur des objectifs et des biais spécifiques, qui peuvent différer considérablement de ceux des autres types. Pour nous rapprocher d'une perspective unifiée de la génération audio, cet article propose un cadre qui utilise la même méthode d'apprentissage pour la génération de la parole, de la musique et des effets sonores. Notre cadre introduit une représentation générale de l'audio, appelée « language of audio » (LOA). Tout audio peut être traduit en LOA sur la base d'AudioMAE, un modèle d'apprentissage de représentation auto-supervisé pré-entraîné. Dans le processus de génération, nous traduisons toutes les modalités en LOA à l'aide d'un modèle GPT-2, et nous effectuons un apprentissage de génération audio auto-supervisé avec un modèle de diffusion latente conditionné sur LOA. Le cadre proposé apporte naturellement des avantages tels que les capacités d'apprentissage en contexte et la réutilisabilité des modèles AudioMAE et de diffusion latente auto-supervisés pré-entraînés. Les expériences sur les principaux benchmarks de text-to-audio, text-to-music et text-to-speech démontrent des performances de pointe ou compétitives par rapport aux approches précédentes. Notre code, notre modèle pré-entraîné et notre démo sont disponibles à l'adresse [ce lien https](https://audioldm.github.io/audioldm2).* Ce pipeline a été contribué par [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) et [Nguyễn Công Tú Anh](https://github.com/tuanh123789). La base de code originale peut être trouvée à [haoheliu/audioldm2](https://github.com/haoheliu/audioldm2). ## Astuces ### Choisir un point de contrôle AudioLDM2 est disponible en trois variantes. Deux de ces points de contrôle s'appliquent à la tâche générale de génération audio à partir de texte. Le troisième point de contrôle est entraîné exclusivement sur la génération musicale à partir de texte. Tous les points de contrôle partagent la même taille de modèle pour les encodeurs de texte et le VAE. Ils diffèrent par la taille et la profondeur du UNet. Consultez le tableau ci-dessous pour plus de détails sur les trois points de contrôle : | Point de contrôle | Tâche | Taille du modèle UNet | Taille totale du modèle | Données d'entraînement / h | |-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------| | [audioldm2](https://huggingface.co/cvssp/audioldm2) | Texte vers audio | 350M | 1.1B | 1150k | | [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | Texte vers audio | 750M | 1.5B | 1150k | | [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | Texte vers musique | 350M | 1.1B | 665k | | [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | Texte vers parole | 350M | 1.1B |10k | | [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | Texte vers parole | 350M | 1.1B | | ### Construire un prompt * Les entrées de prompt descriptives fonctionnent le mieux : utilisez des adjectifs pour décrire le son (par exemple « high quality » ou « clear ») et rendez le prompt contextuellement spécifique (par exemple « water stream in a forest » au lieu de « stream »). * Il est préférable d’utiliser des termes généraux comme « cat » ou « dog » plutôt que des noms propres ou des objets abstraits avec lesquels le modèle peut ne pas être familier. * L'utilisation d'un **prompt négatif** peut considérablement améliorer la qualité de la forme d'onde générée, en orientant la génération loin des termes correspondant à un audio de mauvaise qualité. Essayez d'utiliser un prompt négatif de « Low quality. » ### Contrôle de l'inférence * La _qualité_ de l'échantillon audio prédit 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. * La _longueur_ de l'échantillon audio prédit peut être contrôlée en modifiant l'argument `audio_length_in_s`. ### Évaluation des formes d’onde générées : * La qualité des formes d’onde générées peut varier considérablement en fonction de la graine. Essayez de générer avec différentes graines jusqu’à obtenir un résultat satisfaisant. * 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. 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 pire en conséquence. L’exemple suivant montre comment générer de la musique et de la parole de qualité en appliquant les conseils mentionnés précédemment : [exemple](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2Pipeline.__call__.example). > [!TIP] > Pensez à consulter le [guide des Schedulers](../../using-diffusers/schedulers) pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section [réutilisation des composants entre les pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines. ## AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] #### diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] ```python diffusers.AudioLDM2Pipeline(vae: AutoencoderKL, text_encoder: ClapModel, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.vits.modeling_vits.VitsModel, projection_model: AudioLDM2ProjectionModel, language_model: GPT2LMHeadModel, tokenizer: RobertaTokenizer, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.vits.tokenization_vits.VitsTokenizer, feature_extractor: ClapFeatureExtractor, unet: AudioLDM2UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vocoder: SpeechT5HifiGan) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150) **Paramètres :** vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes. text_encoder ([ClapModel](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapModel)) : premier encodeur de texte figé. AudioLDM2 utilise le modèle d’incorporation conjointe audio-texte [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), plus précisément la variante [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused). La branche texte sert à encoder le prompt texte en une incorporation de prompt. Le modèle audio-texte complet est utilisé pour classer les formes d’onde générées par rapport au prompt texte en calculant des scores de similarité. text_encoder_2 ([`~transformers.T5EncoderModel`, `~transformers.VitsModel`]) : Deuxième encodeur de texte figé. AudioLDM2 utilise l'encodeur de [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/flan-t5-large](https://huggingface.co/google/flan-t5-large). Deuxième encodeur de texte figé utilisé pour la TTS. AudioLDM2 utilise l'encodeur de [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel). projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/fr/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : un modèle entraîné utilisé pour projeter linéairement les états cachés des modèles d’encodeurs de texte premier et second et insérer des embeddings appris pour les jetons SOS et EOS. Les états cachés projetés des deux encodeurs de texte sont concaténés pour fournir l’entrée du modèle de langage. Un embedding de position appris pour les états cachés de Vits language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.GPT2Model)) : un modèle de langage auto-régressif utilisé pour générer une séquence d'états cachés conditionnée sur les sorties projetées des deux encodeurs de texte. tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : Tokenizer pour tokeniser le texte destiné au premier encodeur de texte figé. tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : Tokenizer pour tokeniser le texte destiné au second encodeur de texte figé. feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : Extracteur de caractéristiques pour pré-traiter les formes d'onde audio générées en spectrogrammes log-mel pour le scoring automatique. unet ([UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : un `UNet2DConditionModel` pour débruyer les latents audio encodés. scheduler ([SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler à utiliser en combinaison avec `unet` pour débruyer les latents audio encodés. Peut être l'un des [DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/main/fr/api/schedulers/pndm#diffusers.PNDMScheduler). vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/main/en/model_doc/speecht5#transformers.SpeechT5HifiGan)) : Vocodeur de la classe `SpeechT5HifiGan` pour convertir les latents du spectrogramme de mel en forme d'onde audio finale. Pipeline pour la génération de texte en audio à l'aide d'AudioLDM2. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/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.AudioLDM2Pipeline.__call__]] ```python __call__(prompt: str | list[str] = None, transcription: str | list[str] = None, audio_length_in_s: float | None = None, num_inference_steps: int = 200, guidance_scale: float = 3.5, 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, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None, return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int | None = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, output_type: str | None = 'np') ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L842) **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`. transcription (`str` ou `list[str]`, *facultatif*) --\ La transcription pour la synthèse vocale. audio_length_in_s (`int`, *facultatif*, valeur par défaut 10.24) : La durée de l'échantillon audio généré, en secondes. num_inference_steps (`int`, *facultatif*, valeur par défaut 200) : 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 3,5) : 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. Si `num_waveforms_per_prompt > 1`, un score automatique est effectué entre les sorties générées et l’invite texte. Ce score classe les formes d’onde générées en fonction de leur similarité cosinus avec l’entrée texte dans l’espace d’incorporation conjoint texte-audio. 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/main/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 de spectrogrammes. 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. prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, `negative_prompt_embeds` sont générés à partir de l'argument d'entrée `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées à partir du modèle de langage GPT2. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés à partir du modèle de langage GPT2. 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_prompt_embeds`. S'il n'est pas fourni, le masque d'attention sera calculé à partir de l'argument d'entrée `negative_prompt`. max_new_tokens (`int`, *facultatif*, valeur par défaut None) : Nombre de nouveaux jetons à générer avec le modèle de langage GPT2. S'il n'est pas fourni, le nombre de jetons est pris dans la configuration du modèle. return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [StableDiffusionPipelineOutput](/docs/diffusers/main/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. cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini dans [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). output_type (`str`, *facultatif*, par défaut `"np"`) : 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/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple` Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/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 >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "cvssp/audioldm2" >>> pipe = AudioLDM2Pipeline.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_length_in_s=10.0, ... num_waveforms_per_prompt=3, ... generator=generator, ... ).audios >>> # save the best audio sample (index 0) as a .wav file >>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio[0]) ``` ``` #Using AudioLDM2 for Text To Speech >>> import scipy >>> import torch >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "anhnct/audioldm2_gigaspeech" >>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16) >>> pipe = pipe.to("cuda") >>> # define the prompts >>> prompt = "A female reporter is speaking" >>> transcript = "wish you have a good day" >>> # set the seed for generator >>> generator = torch.Generator("cuda").manual_seed(0) >>> # run the generation >>> audio = pipe( ... prompt, ... transcription=transcript, ... num_inference_steps=200, ... audio_length_in_s=10.0, ... num_waveforms_per_prompt=2, ... generator=generator, ... max_new_tokens=512, #Must set max_new_tokens equa to 512 for TTS ... ).audios >>> # save the best audio sample (index 0) as a .wav file >>> scipy.io.wavfile.write("tts.wav", rate=16000, data=audio[0]) ``` #### enable_model_cpu_offload[[diffusers.AudioLDM2Pipeline.enable_model_cpu_offload]] ```python enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = 'cuda') ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226) Décharge tous les modèles sur le CPU à l'aide de accelerate, réduisant ainsi l'utilisation de la mémoire avec un impact faible sur les performances. Par rapport à `enable_sequential_cpu_offload`, cette méthode déplace un modèle entier à la fois sur le GPU lorsque sa méthode `forward` est appelée, et le modèle reste sur le GPU jusqu'à l'exécution du modèle suivant. Les économies de mémoire sont moindres qu'avec `enable_sequential_cpu_offload`, mais les performances sont bien meilleures grâce à l'exécution itérative de `unet`. #### encode_prompt[[diffusers.AudioLDM2Pipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_waveforms_per_prompt, do_classifier_free_guidance, transcription = None, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L329) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder transcription (`str` ou `list[str]`) : transcription du texte en parole device (`torch.device`) : appareil torch num_waveforms_per_prompt (`int`) : nombre de formes d'onde à générer par invite do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération audio. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n'est pas utilisée (c'est-à-dire ignoré si `guidance_scale` est inférieur à `1`). prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte précalculés issus du modèle Flan T5. 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*) : Incrustations de texte négatif précalculées issues du modèle Flan T5. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera calculé à partir de l'argument d'entrée `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées à partir du modèle de langage GPT2. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés à partir du modèle de langage GPT2. 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_prompt_embeds`. S'il n'est pas fourni, le masque d'attention sera calculé à partir de l'argument d'entrée `negative_prompt`. max_new_tokens (`int`, *facultatif*, valeur par défaut None) : Le nombre de nouveaux jetons à générer avec le modèle de langage GPT2. **Retourne :** prompt_embeds (`torch.Tensor`) Embeddings de texte issus du modèle Flan T5. attention_mask (`torch.LongTensor`): Masque d'attention à appliquer aux `prompt_embeds`. generated_prompt_embeds (`torch.Tensor`): Embeddings de texte générés à partir du modèle de langage GPT2. Encode le prompt dans les états cachés de l'encodeur de texte. Exemple : ```python >>> import scipy >>> import torch >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "cvssp/audioldm2" >>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16) >>> pipe = pipe.to("cuda") >>> # Get text embedding vectors >>> prompt_embeds, attention_mask, generated_prompt_embeds = pipe.encode_prompt( ... prompt="Techno music with a strong, upbeat tempo and high melodic riffs", ... device="cuda", ... do_classifier_free_guidance=True, ... ) >>> # Pass text embeddings to pipeline for text-conditional audio generation >>> audio = pipe( ... prompt_embeds=prompt_embeds, ... attention_mask=attention_mask, ... generated_prompt_embeds=generated_prompt_embeds, ... num_inference_steps=200, ... audio_length_in_s=10.0, ... ).audios[0] >>> # save generated audio sample >>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio) ``` #### generate_language_model[[diffusers.AudioLDM2Pipeline.generate_language_model]] ```python generate_language_model(inputs_embeds: Tensor = None, max_new_tokens: int = 8, **model_kwargs) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L276) **Paramètres :** inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : La séquence utilisée comme invite pour la génération. max_new_tokens (`int`) : Nombre de nouveaux jetons à générer. model_kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc des kwargs spécifiques au modèle supplémentaires qui seront transmis à la fonction `forward` du modèle. **Returns:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`) La séquence d'états cachés générés. Génère une séquence d'états cachés à partir du modèle de langage, conditionnée par les entrées d'incorporation. ## AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]] #### diffusers.AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]] ```python diffusers.AudioLDM2ProjectionModel(text_encoder_dim, text_encoder_1_dim, langauge_model_dim, use_learned_position_embedding = None, max_seq_length = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60) **Paramètres :** text_encoder_dim (`int`) : Dimensionnalité des embeddings de texte issus du premier encodeur de texte (CLAP). text_encoder_1_dim (`int`) : Dimensionnalité des embeddings de texte issus du second encodeur de texte (T5 ou VITS). langauge_model_dim (`int`) : Dimensionnalité des embeddings de texte issus du modèle de langage (GPT2). Un modèle de projection linéaire simple pour mapper deux embeddings de texte vers un espace latent partagé. Il insère également des vecteurs d'embedding appris au début et à la fin de chaque séquence d'embedding de texte, respectivement. Chaque variable suivie de `_1` fait référence à celle correspondant au second encodeur de texte. Sinon, elle provient du premier. #### forward[[diffusers.AudioLDM2ProjectionModel.forward]] ```python forward(hidden_states: typing.Optional[torch.Tensor] = None, hidden_states_1: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, attention_mask_1: typing.Optional[torch.LongTensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L104) **Paramètres :** hidden_states (`torch.Tensor` de forme `(batch_size, sequence_length, text_encoder_dim)`, *facultatif*) : Embeddings de texte issus du premier encodeur de texte (CLAP). hidden_states_1 (`torch.Tensor` de forme `(batch_size, sequence_length_1, text_encoder_1_dim)`, *facultatif*) : Embeddings de texte issus du second encodeur de texte (T5 ou VITS). attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque d'attention pour `hidden_states`. attention_mask_1 (`torch.LongTensor` de forme `(batch_size, sequence_length_1)`, *facultatif*) : Masque d'attention pour `hidden_states_1`. **Retourne :** `AudioLDM2ProjectionModelOutput` Les embeddings de texte projetés des deux encodeurs de texte, concaténés le long de la dimension de séquence, ainsi que leur masque d'attention combiné. ## AudioLDM2UNet2DConditionModel[[diffusers.AudioLDM2UNet2DConditionModel]] #### diffusers.AudioLDM2UNet2DConditionModel[[diffusers.AudioLDM2UNet2DConditionModel]] ```python diffusers.AudioLDM2UNet2DConditionModel(sample_size: int | None = None, in_channels: int = 4, out_channels: int = 4, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] = 1, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, class_embeddings_concat: bool = False) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45) **Paramètres :** sample_size (`int` ou `tuple[int, int]`, *facultatif*, valeur par défaut `None`) : Hauteur et largeur de l'échantillon d'entrée/sortie. in_channels (`int`, *facultatif*, valeur par défaut 4) : Nombre de canaux dans l'échantillon d'entrée. out_channels (`int`, *facultatif*, par défaut 4) : Nombre de canaux dans la sortie. flip_sin_to_cos (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut inverser le sin en cos dans l'embedding temporel. freq_shift (`int`, *facultatif*, valeur par défaut 0) : Le décalage de fréquence à appliquer à l'incorporation temporelle. down_block_types (`tuple[str]`, *facultatif*, par défaut `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Le tuple de blocs de downsampling à utiliser. mid_block_type (`str`, *facultatif*, valeur par défaut `"UNetMidBlock2DCrossAttn"`) : Type de bloc pour la partie centrale du UNet, il ne peut être que `UNetMidBlock2DCrossAttn` pour AudioLDM2. up_block_types (`tuple[str]`, *facultatif*, par défaut `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Le tuple de blocs de suréchantillonnage à utiliser. only_cross_attention (`bool` ou `tuple[bool]`, *facultatif*, par défaut `False`) : Indique si l'auto-attention doit être incluse dans les blocs de base du transformer, voir `BasicTransformerBlock`. block_out_channels (`tuple[int]`, *facultatif*, par défaut `(320, 640, 1280, 1280)`) : Le tuple des canaux de sortie pour chaque bloc. layers_per_block (`int`, *facultatif*, valeur par défaut 2) : Le nombre de couches par bloc. downsample_padding (`int`, *facultatif*, valeur par défaut 1) : Le padding à utiliser pour la convolution de downsampling. mid_block_scale_factor (`float`, *facultatif*, valeur par défaut 1.0) : Le facteur d'échelle à utiliser pour le bloc intermédiaire. act_fn (`str`, *facultatif*, par défaut `"silu"`) : La fonction d'activation à utiliser. norm_num_groups (`int`, *facultatif*, valeur par défaut 32) : Le nombre de groupes à utiliser pour la normalisation. Si `None`, les couches de normalisation et d'activation sont ignorées lors du post-traitement. norm_eps (`float`, *facultatif*, par défaut 1e-5) : L'épsilon à utiliser pour la normalisation. cross_attention_dim (`int` ou `tuple[int]`, *facultatif*, valeur par défaut 1280) : La dimension des fonctionnalités d'attention croisée. transformer_layers_per_block (`int` ou `tuple[int]`, *facultatif*, valeur par défaut 1) : Le nombre de blocs de transformateur de type `BasicTransformerBlock`. Ne concerne que `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`. attention_head_dim (`int`, *facultatif*, valeur par défaut 8) : La dimension des têtes d'attention. num_attention_heads (`int`, *facultatif*) : Le nombre de têtes d'attention. S'il n'est pas défini, la valeur par défaut est `attention_head_dim` resnet_time_scale_shift (`str`, *facultatif*, valeur par défaut `"default"`) : configuration du décalage d'échelle temporelle pour les blocs ResNet (voir `ResnetBlock2D`). Choisissez entre `default` et `scale_shift`. class_embed_type (`str`, *facultatif*, valeur par défaut `None`) : Le type d’embedding de classe à utiliser, qui est finalement additionné aux embeddings temporels. Choisissez parmi `None`, `"timestep"`, `"identity"`, `"projection"` ou `"simple_projection"`. num_class_embeds (`int`, *facultatif*, valeur par défaut `None`) : Dimension d'entrée de la matrice d'incorporation apprenable à projeter vers `time_embed_dim`, lors de l'utilisation d'un conditionnement par classe avec `class_embed_type` égal à `None`. time_embedding_type (`str`, *facultatif*, par défaut `positional`) : Le type d'incorporation de position à utiliser pour les pas de temps. Choisissez entre `positional` ou `fourier`. time_embedding_dim (`int`, *facultatif*, valeur par défaut `None`) : Remplacement facultatif pour la dimension de l'embedding temporel projeté. time_embedding_act_fn (`str`, *facultatif*, valeur par défaut `None`) : Fonction d'activation optionnelle à utiliser une seule fois sur les embeddings temporels avant qu'ils ne soient transmis au reste du UNet. Choisissez parmi `silu`, `mish`, `gelu` et `swish`. timestep_post_act (`str`, *facultatif*, valeur par défaut `None`) : La seconde fonction d'activation à utiliser dans l'encodage du pas de temps. Choisissez parmi `silu`, `mish` et `gelu`. time_cond_proj_dim (`int`, *facultatif*, par défaut `None`) : La dimension de la couche `cond_proj` dans l'encodage du pas de temps. conv_in_kernel (`int`, *facultatif*, par défaut `3`) : La taille du noyau de la couche `conv_in`. conv_out_kernel (`int`, *facultatif*, par défaut `3`) : La taille du noyau de la couche `conv_out`. projection_class_embeddings_input_dim (`int`, *facultatif*) : La dimension de l'entrée `class_labels` lorsque `class_embed_type="projection"`. Obligatoire lorsque `class_embed_type="projection"`. class_embeddings_concat (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut concaténer les embeddings temporels avec les embeddings de classe. Un modèle 2D UNet conditionnel qui prend un échantillon bruité, un état conditionnel et un pas de temps, et renvoie une sortie de la même forme. Par rapport au [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) standard, cette variante inclut facultativement une couche d'auto-attention supplémentaire dans chaque bloc Transformer, ainsi que plusieurs couches d'attention croisée. Elle permet également jusqu'à deux embeddings d'attention croisée, `encoder_hidden_states` et `encoder_hidden_states_1`. Ce modèle hérite de [ModelMixin](/docs/diffusers/main/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (tels que le téléchargement ou l'enregistrement). #### forward[[diffusers.AudioLDM2UNet2DConditionModel.forward]] ```python forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True, encoder_hidden_states_1: typing.Optional[torch.Tensor] = None, encoder_attention_mask_1: typing.Optional[torch.Tensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494) **Paramètres :** sample (`torch.Tensor`) : Le tenseur d'entrée bruité de la forme suivante `(batch, channel, height, width)`. timestep (`torch.Tensor` ou `float` ou `int`) : Le nombre de pas de temps pour débruitiser une entrée. encoder_hidden_states (`torch.Tensor`) : Les états cachés de l'encodeur avec la forme `(batch, sequence_length, feature_dim)`. encoder_attention_mask (`torch.Tensor`) : Un masque d'attention croisée de forme `(batch, sequence_length)` est appliqué à `encoder_hidden_states`. Si `True`, le masque est conservé, sinon, si `False`, il est supprimé. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d'attention correspondant aux jetons « supprimés ». return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) plutôt qu'un simple tuple. cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttnProcessor`. encoder_hidden_states_1 (`torch.Tensor`, *facultatif*) : Un second ensemble d'états cachés de l'encodeur de forme `(batch, sequence_length_2, feature_dim_2)`. Peut être utilisé pour conditionner le modèle sur un ensemble d'embeddings différent de `encoder_hidden_states`. encoder_attention_mask_1 (`torch.Tensor`, *facultatif*) : Un masque d'attention croisée de forme `(batch, sequence_length_2)` est appliqué à `encoder_hidden_states_1`. Si `True`, le masque est conservé, sinon, si `False`, il est supprimé. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d'attention correspondant aux jetons « à supprimer ». **Retourne :** [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) ou `tuple` Si `return_dict` est True, un [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est le tenseur d'échantillon. La méthode forward du [AudioLDM2UNet2DConditionModel](/docs/diffusers/main/fr/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel). ## AudioPipelineOutput[[diffusers.AudioPipelineOutput]] #### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]] ```python diffusers.AudioPipelineOutput(audios: ndarray) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L149) **Paramètres :** audios (`np.ndarray`) : Liste d'échantillons audio débruités d'un tableau NumPy de forme `(batch_size, num_channels, sample_rate)`. Classe de sortie pour les pipelines audio.