diffusers/main/fr/api/pipelines/audioldm2.md

AudioLDM 2

AudioLDM 2 a été proposé dans AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining 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, 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 et l'encodeur de Flan-T5. Ces embeddings de texte sont ensuite projetés dans un espace d'embedding partagé par un AudioLDM2ProjectionModel. Un 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 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.

Ce pipeline a été contribué par sanchit-gandhi et Nguyễn Công Tú Anh. La base de code originale peut être trouvée à 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	Texte vers audio	350M	1.1B	1150k
audioldm2-large	Texte vers audio	750M	1.5B	1150k
audioldm2-music	Texte vers musique	350M	1.1B	665k
audioldm2-gigaspeech	Texte vers parole	350M	1.1B	10k
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.

Pensez à consulter le guide des 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 pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines.

AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

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

Paramètres :

vae (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) : premier encodeur de texte figé. AudioLDM2 utilise le modèle d’incorporation conjointe audio-texte CLAP, plus précisément la variante 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, plus précisément la variante google/flan-t5-large. Deuxième encodeur de texte figé utilisé pour la TTS. AudioLDM2 utilise l'encodeur de Vits.

projection_model (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) : 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) : 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) : 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) : un UNet2DConditionModel pour débruyer les latents audio encodés.

scheduler (SchedulerMixin) : Un scheduler à utiliser en combinaison avec unet pour débruyer les latents audio encodés. Peut être l'un des DDIMScheduler, LMSDiscreteScheduler ou PNDMScheduler.

vocoder (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. 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]]

__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

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. S'applique uniquement 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 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 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.

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

enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = 'cuda')

Source

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

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

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 :

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

generate_language_model(inputs_embeds: Tensor = None, max_new_tokens: int = 8, **model_kwargs)

Source

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.Tensorof 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]]

diffusers.AudioLDM2ProjectionModel(text_encoder_dim, text_encoder_1_dim, langauge_model_dim, use_learned_position_embedding = None, max_seq_length = None)

Source

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

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

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

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[str] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int] = (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

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

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

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 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 ou tuple

Si return_dict est True, un UNet2DConditionOutput est renvoyé, sinon un tuple est renvoyé dont le premier élément est le tenseur d'échantillon.

La méthode forward du AudioLDM2UNet2DConditionModel.

AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput(audios: ndarray)

Source

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.