Hugging Face's logo

Diffusers documentation

AudioLDM 2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 des capacités d’apprentissage en contexte et des modèles AudioMAE et de diffusion latente auto-supervisés pré-entraînés réutilisables. 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 à cette URL 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ôleTâcheTaille du modèle UNetTaille totale du modèleDonnées d'entraînement / h
audioldm2Texte vers audio350M1.1B1150k
audioldm2-largeTexte vers audio750M1.5B1150k
audioldm2-musicTexte vers musique350M1.1B665k
audioldm2-gigaspeechTexte vers parole350M1.1B10k
audioldm2-ljspeechTexte vers parole350M1.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 spécifiques 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

classe diffusers.AudioLDM2Pipeline

< >

( vae: AutoencoderKLtext_encoder: ClapModeltext_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.vits.modeling_vits.VitsModelprojection_model: AudioLDM2ProjectionModellanguage_model: GPT2LMHeadModeltokenizer: RobertaTokenizertokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.vits.tokenization_vits.VitsTokenizerfeature_extractor: ClapFeatureExtractorunet: AudioLDM2UNet2DConditionModelscheduler: KarrasDiffusionSchedulersvocoder: SpeechT5HifiGan )

Paramètres

  • vae (AutoencoderKL) — Modèle de Variational Auto-Encoder (VAE) pour encoder et 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’embeddings audio-texte conjoint CLAP, plus précisément la variante laion/clap-htsat-unfused. La branche texte est utilisée pour encoder le prompt texte en un embedding 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. Le deuxième encodeur de texte figé est 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) — Jetoniseur pour tokeniser le texte destiné au premier encodeur de texte figé.
  • tokenizer_2 ([~transformers.T5Tokenizer, ~transformers.VitsTokenizer]) — Jetoniseur 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 planificateur à 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.).

__call__

< >

( prompt: str | list[str] = Nonetranscription: str | list[str] = Noneaudio_length_in_s: float | None = Nonenum_inference_steps: int = 200guidance_scale: float = 3.5negative_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] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonegenerated_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_generated_prompt_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonenegative_attention_mask: typing.Optional[torch.LongTensor] = Nonemax_new_tokens: int | None = Nonereturn_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int | None = 1cross_attention_kwargs: dict[str, typing.Any] | None = Noneoutput_type: str | None = 'np' ) → 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.
  • transcription (str or list[str], optional) —\ The transcript for text to speech.
  • audio_length_in_s (int, facultatif, 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 de guidance scale plus élevée encourage 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. 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 joint texte-audio.
  • 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 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'ils ne sont pas fournis, les negative_prompt_embeds sont générés à partir de l'argument d'entrée negative_prompt.
  • generated_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte pré-générés par le modèle de langage GPT2. 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 générés à partir de l'argument d'entrée prompt.
  • negative_generated_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés par le modèle de langage GPT2. 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_prompt_embeds. S’il n’est pas fourni, le masque d’attention est 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 sera 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 au 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 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
>>> 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

< >

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

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

< >

( promptdevicenum_waveforms_per_promptdo_classifier_free_guidancetranscription = Nonenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonegenerated_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_generated_prompt_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonenegative_attention_mask: typing.Optional[torch.LongTensor] = Nonemax_new_tokens: int | None = None ) → prompt_embeds (torch.Tensor)

Paramètres

  • prompt (str ou list[str], facultatif) — prompt à encoder
  • transcription (str ou list[str]) — transcription du texte en parole
  • device (torch.device) — dispositif 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 classifier free guidance ou non
  • negative_prompt (str ou list[str], facultatif) — Le 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 le guidage n'est pas utilisé (c'est-à-dire ignoré si guidance_scale est inférieur à 1).
  • prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte précalculés par le 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) — Embeddings de texte négatifs précalculés par le 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, negative_prompt_embeds sera calculé à partir de l'argument d'entrée negative_prompt.
  • generated_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte pré-générés par le modèle de langage GPT2. 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 générés à partir de l'argument d'entrée prompt.
  • negative_generated_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés par le modèle de langage GPT2. 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_prompt_embeds. S’il n’est pas fourni, le masque d’attention est 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

< >

( inputs_embeds: Tensor = Nonemax_new_tokens: int = 8**model_kwargs ) → inputs_embeds (torch.Tensorof shape(batch_size, sequence_length, hidden_size)`)

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.

Retourne

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

classe diffusers.AudioLDM2ProjectionModel

< >

( text_encoder_dimtext_encoder_1_dimlangauge_model_dimuse_learned_position_embedding = Nonemax_seq_length = None )

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

< >

( hidden_states: typing.Optional[torch.Tensor] = Nonehidden_states_1: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneattention_mask_1: typing.Optional[torch.LongTensor] = None ) → AudioLDM2ProjectionModelOutput

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

classe diffusers.AudioLDM2UNet2DConditionModel

< >

( sample_size: int | None = Nonein_channels: int = 4out_channels: int = 4flip_sin_to_cos: bool = Truefreq_shift: int = 0down_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] = Falseblock_out_channels: tuple = (320, 640, 1280, 1280)layers_per_block: int | tuple[int] = 2downsample_padding: int = 1mid_block_scale_factor: float = 1act_fn: str = 'silu'norm_num_groups: int | None = 32norm_eps: float = 1e-05cross_attention_dim: int | tuple[int] = 1280transformer_layers_per_block: int | tuple[int] = 1attention_head_dim: int | tuple[int] = 8num_attention_heads: int | tuple[int] | None = Noneuse_linear_projection: bool = Falseclass_embed_type: str | None = Nonenum_class_embeds: int | None = Noneupcast_attention: bool = Falseresnet_time_scale_shift: str = 'default'time_embedding_type: str = 'positional'time_embedding_dim: int | None = Nonetime_embedding_act_fn: str | None = Nonetimestep_post_act: str | None = Nonetime_cond_proj_dim: int | None = Noneconv_in_kernel: int = 3conv_out_kernel: int = 3projection_class_embeddings_input_dim: int | None = Noneclass_embeddings_concat: bool = False )

Paramètres

  • sample_size (int ou tuple[int, int], facultatif, par défaut None) — Hauteur et largeur de l'échantillon d'entrée/sortie.
  • in_channels (int, facultatif, 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 sous-échantillonnage à utiliser.
  • mid_block_type (str, facultatif, par défaut "UNetMidBlock2DCrossAttn") — Type de bloc pour la partie centrale de l’UNet ; pour AudioLDM2, il ne peut être que UNetMidBlock2DCrossAttn.
  • up_block_types (tuple[str], facultatif, par défaut ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")) — Le tuple de blocs de remonte à utiliser.
  • only_cross_attention (bool ou tuple[bool], facultatif, par défaut False) — Indique s'il faut inclure l'auto-attention 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, valeur par défaut 1e-5) — L'épsilon à utiliser pour la normalisation.
  • cross_attention_dim (int ou tuple[int], facultatif, par défaut 1280) — La dimension des fonctionnalités d'attention croisée.
  • transformer_layers_per_block (int ou tuple[int], facultatif, par défaut 1) — Le nombre de blocs 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, par défaut "default") — Configuration du décalage de l'échelle temporelle pour les blocs ResNet (voir ResnetBlock2D). Choisissez entre default et scale_shift.
  • class_embed_type (str, facultatif, par défaut None) — Le type d’incorporation de classe à utiliser, qui est finalement additionné aux incorporations temporelles. Choisissez parmi None, "timestep", "identity", "projection" ou "simple_projection".
  • num_class_embeds (int, facultatif, par défaut None) — Dimension d’entrée de la matrice d’embeddings apprenables à 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 et fourier.
  • time_embedding_dim (int, facultatif, par défaut None) — Substitution facultative pour la dimension de l’embedding de temps projeté.
  • time_embedding_act_fn (str, facultatif, par défaut None) — Fonction d’activation optionnelle à utiliser une seule fois sur les embeddings de temps avant qu’ils ne soient transmis au reste du UNet. Choisissez parmi silu, mish, gelu et swish.
  • timestep_post_act (str, facultatif, 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 en entrée et renvoie une sortie de forme échantillon. 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 (téléchargement ou sauvegarde, par exemple).

forward

< >

( sample: Tensortimestep: typing.Union[torch.Tensor, float, int]encoder_hidden_states: Tensorclass_labels: typing.Optional[torch.Tensor] = Nonetimestep_cond: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonecross_attention_kwargs: dict[str, typing.Any] | None = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonereturn_dict: bool = Trueencoder_hidden_states_1: typing.Optional[torch.Tensor] = Noneencoder_attention_mask_1: typing.Optional[torch.Tensor] = None ) → UNet2DConditionOutput or tuple

Paramètres

  • sample (torch.Tensor) — Le tenseur d'entrée bruité de forme (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, de 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 « à supprimer ».
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un UNet2DConditionOutput plutôt qu'un simple tuplet.
  • cross_attention_kwargs (dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à 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 celui 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

classe diffusers.AudioPipelineOutput

< >

( audios: ndarray )

Paramètres

  • audios (np.ndarray) — Liste d'échantillons audio débruités sous forme de tableau NumPy de forme (batch_size, num_channels, sample_rate).

Classe de sortie pour les pipelines audio.

Update on GitHub

←ACE-Step LongCat-AudioDiT→