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

O AudioLDM 2 foi proposto em AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining por Haohe Liu et al. O AudioLDM 2 recebe um prompt de texto como entrada e prevê o áudio correspondente. Ele pode gerar efeitos sonoros condicionados por texto, fala humana e música.

Inspirado no Stable Diffusion, o AudioLDM 2 é um modelo de difusão latente (LDM) de texto para áudio que aprende representações contínuas de áudio a partir de embeddings de texto. Dois modelos de codificador de texto são usados para calcular os embeddings de texto a partir de uma entrada de prompt: o ramo de texto do CLAP e o codificador do Flan-T5. Esses embeddings de texto são então projetados para um espaço de embeddings compartilhado por um AudioLDM2ProjectionModel. Um GPT2 modelo de linguagem (LM) é usado para prever auto-regressivamente oito novos vetores de embedding, condicionados aos embeddings projetados do CLAP e do Flan-T5. Os vetores de embedding gerados e os embeddings de texto do Flan-T5 são usados como condicionamento de atenção cruzada no LDM. O UNet do AudioLDM 2 é único no sentido de que recebe dois embeddings de atenção cruzada, em oposição a um único condicionamento de atenção cruzada, como na maioria dos outros LDMs.

O resumo do artigo é o seguinte:

Embora a geração de áudio compartilhe semelhanças entre diferentes tipos de áudio, como fala, música e efeitos sonoros, o projeto de modelos para cada tipo exige uma consideração cuidadosa de objetivos e vieses específicos que podem diferir significativamente dos de outros tipos. Para nos aproximar de uma perspectiva unificada da geração de áudio, este artigo propõe um framework que utiliza o mesmo método de aprendizado para a geração de fala, música e efeitos sonoros. Nosso framework introduz uma representação geral de áudio, chamada “language of audio” (LOA). Qualquer áudio pode ser traduzido para LOA com base no AudioMAE, um modelo de aprendizado de representação pré-treinado auto-supervisionado. No processo de geração, traduzimos qualquer modalidade para LOA usando um modelo GPT-2 e realizamos o aprendizado de geração de áudio auto-supervisionado com um modelo de difusão latente condicionado em LOA. O framework proposto traz naturalmente vantagens, como capacidades de in-context learning e modelos pré-treinados auto-supervisionados reutilizáveis de AudioMAE e difusão latente. Experimentos nos principais benchmarks de text-to-audio, text-to-music e text-to-speech demonstram desempenho state-of-the-art ou competitivo em relação a abordagens anteriores. Nosso código, modelo pré-treinado e demo estão disponíveis em this https URL.

Este pipeline foi contribuído por sanchit-gandhi e Nguyễn Công Tú Anh. A base de código original pode ser encontrada em haoheliu/audioldm2.

Dicas

Escolhendo um checkpoint

O AudioLDM2 vem em três variantes. Dois desses checkpoints são aplicáveis à tarefa geral de geração de áudio a partir de texto. O terceiro checkpoint é treinado exclusivamente para geração de música a partir de texto.

Todos os checkpoints compartilham o mesmo tamanho de modelo para os codificadores de texto e o VAE. Eles diferem no tamanho e na profundidade do UNet. Veja a tabela abaixo para detalhes sobre os três checkpoints:

CheckpointTarefaTamanho do Modelo UNetTamanho Total do ModeloDados de Treinamento / h
audioldm2Texto para áudio350M1.1B1150k
audioldm2-largeTexto para áudio750M1.5B1150k
audioldm2-musicTexto para música350M1.1B665k
audioldm2-gigaspeechTexto para fala350M1.1B10k
audioldm2-ljspeechTexto para fala350M1.1B

Construindo um prompt

  • Prompts descritivos funcionam melhor: use adjetivos para descrever o som (por exemplo, “high quality” ou “clear”) e torne o prompt específico em relação ao contexto (por exemplo, “water stream in a forest” em vez de “stream”).
  • É melhor usar termos gerais, como “cat” ou “dog”, em vez de nomes específicos ou objetos abstratos com os quais o modelo pode não estar familiarizado.
  • O uso de um prompt negativo pode melhorar significativamente a qualidade da forma de onda gerada, direcionando a geração para longe de termos que correspondem a áudio de baixa qualidade. Tente usar um prompt negativo de “Low quality.”

Controlando a inferência

  • A qualidade da amostra de áudio prevista pode ser controlada pelo argumento num_inference_steps; um número maior de etapas resulta em áudio de maior qualidade, porém com inferência mais lenta.
  • O length da amostra de áudio prevista pode ser controlado variando o argumento audio_length_in_s.

Avaliando formas de onda geradas:

  • A qualidade das formas de onda geradas pode variar significativamente com base na semente. Tente gerar com diferentes sementes até encontrar uma geração satisfatória.
  • Várias formas de onda podem ser geradas de uma só vez: defina num_waveforms_per_prompt para um valor maior que 1. A pontuação automática será realizada entre as formas de onda geradas e o texto do prompt, e os áudios serão ranqueados do melhor para o pior de acordo com isso.

O exemplo a seguir demonstra como construir uma boa geração de música e fala usando as dicas mencionadas anteriormente: exemplo.

Certifique-se de consultar o guia de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção reutilização de componentes entre pipelines para aprender a carregar eficientemente os mesmos componentes em vários 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 )

Parâmetros

  • vae (AutoencoderKL) — Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.
  • text_encoder (ClapModel) — Primeiro codificador de texto congelado. O AudioLDM2 usa o modelo de incorporação conjunta de áudio e texto CLAP, especificamente a variante laion/clap-htsat-unfused. O ramo de texto é usado para codificar o prompt de texto em uma incorporação de prompt. O modelo completo de áudio e texto é usado para classificar as formas de onda geradas em relação ao prompt de texto, calculando pontuações de similaridade.
  • text_encoder_2 ([~transformers.T5EncoderModel, ~transformers.VitsModel]) — Segundo codificador de texto congelado. O AudioLDM2 usa o codificador do T5, especificamente a variante google/flan-t5-large. O segundo codificador de texto congelado é usado para TTS. O AudioLDM2 usa o codificador do Vits.
  • projection_model (AudioLDM2ProjectionModel) — Um modelo treinado usado para projetar linearmente os hidden-states dos modelos de codificador de texto primeiro e segundo e inserir embeddings de tokens SOS e EOS aprendidos. Os hidden-states projetados dos dois codificadores de texto são concatenados para dar a entrada para o modelo de linguagem. Um Learned Position Embedding para os hidden-states do Vits
  • language_model (GPT2Model) — Um modelo de linguagem auto-regressivo usado para gerar uma sequência de hidden-states condicionada às saídas projetadas dos dois codificadores de texto.
  • tokenizer (RobertaTokenizer) — Tokenizer para tokenizar o texto do primeiro text-encoder congelado.
  • tokenizer_2 ([~transformers.T5Tokenizer, ~transformers.VitsTokenizer]) — Tokenizer para tokenizar o texto para o segundo text-encoder congelado.
  • feature_extractor (ClapFeatureExtractor) — Extrator de recursos para pré-processar formas de onda de áudio geradas em espectrogramas log-mel para pontuação automática.
  • unet (UNet2DConditionModel) — Um UNet2DConditionModel para desruidar os latentes de áudio codificados.
  • scheduler (SchedulerMixin) — Um scheduler a ser usado em combinação com unet para desruidar os latentes de áudio codificados. Pode ser um de DDIMScheduler, LMSDiscreteScheduler ou PNDMScheduler.
  • vocoder (SpeechT5HifiGan) — Vocoder da classe SpeechT5HifiGan para converter os latentes do mel-espectrograma na forma de onda de áudio final.

Pipeline para geração de texto para áudio usando AudioLDM2.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, 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

Parâmetros

  • prompt (str ou list[str], opcional) — O prompt ou os prompts para orientar a geração de áudio. Se não definido, você precisa passar prompt_embeds.
  • transcription (str ou list[str], opcional) —\ A transcrição para texto para fala.
  • audio_length_in_s (int, opcional, padrão 10.24) — O comprimento da amostra de áudio gerada, em segundos.
  • num_inference_steps (int, opcional, padrão 200) — O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em um áudio de maior qualidade, à custa de uma inferência mais lenta.
  • guidance_scale (float, opcional, padrão 3.5) — Um valor mais alto de guidance scale incentiva o modelo a gerar áudio que esteja intimamente ligado ao texto prompt, em detrimento de uma menor qualidade sonora. O guidance scale é ativado quando guidance_scale > 1.
  • negative_prompt (str ou list[str], opcional) — O prompt ou os prompts para orientar o que não incluir na geração de áudio. Se não definido, é necessário passar negative_prompt_embeds em vez disso. Ignorado quando não está usando orientação (guidance_scale < 1).
  • num_waveforms_per_prompt (int, opcional, padrão 1) — O número de formas de onda a serem geradas por prompt. Se num_waveforms_per_prompt > 1, uma pontuação automática é realizada entre as saídas geradas e o prompt de texto. Essa pontuação classifica as formas de onda geradas com base em sua similaridade cosseno com a entrada de texto no espaço de incorporação conjunto de texto e áudio.
  • eta (float, opcional, padrão 0.0) — Corresponde ao parâmetro eta (η) do paper DDIM. Aplica-se apenas ao DDIMScheduler e é ignorado em outros schedulers.
  • generator (torch.Generator ou list[torch.Generator], opcional) — Um torch.Generator para tornar a geração determinística.
  • latents (torch.Tensor, opcional) — Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de espectrogramas. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o generator aleatório fornecido.
  • prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto (ponderação do prompt). Se não for fornecido, os negative_prompt_embeds são gerados a partir do argumento de entrada negative_prompt.
  • generated_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-geradas pelo modelo de linguagem GPT2. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entrada prompt.
  • negative_generated_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto negativos pré-gerados pelo modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, o peso do prompt. Se não for fornecido, negative_prompt_embeds será calculado a partir do argumento de entrada negative_prompt.
  • attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos prompt_embeds. Se não for fornecida, a máscara de atenção será calculada a partir do argumento de entrada prompt.
  • negative_attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos negative_prompt_embeds. Se não for fornecida, a máscara de atenção será calculada a partir do argumento de entrada negative_prompt.
  • max_new_tokens (int, opcional, padrão None) — Número de novos tokens a serem gerados com o modelo de linguagem GPT2. Se não for fornecido, o número de tokens será obtido da configuração do modelo.
  • return_dict (bool, opcional, padrão True) — Se deve ou não retornar um StableDiffusionPipelineOutput em vez de uma tupla simples.
  • callback (Callable, opcional) — Uma função que é chamada a cada callback_steps passos durante a inferência. A função é chamada com os seguintes argumentos: callback(step: int, timestep: int, latents: torch.Tensor).
  • callback_steps (int, opcional, padrão 1) — A frequência com que a função callback é chamada. Se não for especificada, o callback é chamado a cada etapa.
  • cross_attention_kwargs (dict, opcional) — Um dicionário de kwargs que, se especificado, é passado ao AttentionProcessor conforme definido em self.processor.
  • output_type (str, opcional, padrão "np") — O formato de saída do áudio gerado. Escolha entre "np" para retornar um np.ndarray do NumPy ou "pt" para retornar um objeto torch.Tensor do PyTorch. Defina como "latent" para retornar a saída do modelo de difusão latente (LDM).

Retorna

StableDiffusionPipelineOutput ou tuple

Se return_dict for True, StableDiffusionPipelineOutput é retornado, caso contrário, uma tuple é retornada, onde o primeiro elemento é uma lista com o áudio gerado.

A função de chamada do pipeline para geração.

Exemplos:

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

Desloca todos os modelos para a CPU usando accelerate, reduzindo o uso de memória com baixo impacto no desempenho. Em comparação com enable_sequential_cpu_offload, este método move um modelo inteiro de cada vez para a GPU quando seu método forward é chamado, e o modelo permanece na GPU até que o próximo modelo seja executado. As economias de memória são menores do que com enable_sequential_cpu_offload, mas o desempenho é muito melhor devido à execução iterativa do 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)

Parâmetros

  • prompt (str ou list[str], opcional) — prompt a ser codificado
  • transcription (str ou list[str]) — transcrição de texto para fala
  • device (torch.device) — dispositivo torch
  • num_waveforms_per_prompt (int) — número de formas de onda que devem ser geradas por prompt
  • do_classifier_free_guidance (bool) — se deve usar classifier free guidance ou não
  • negative_prompt (str ou list[str], opcional) — O prompt ou os prompts que não devem orientar a geração de áudio. Se não for definido, é necessário passar negative_prompt_embeds em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se guidance_scale for menor que 1).
  • prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-computadas do modelo Flan T5. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompt. Se não forem fornecidas, as incorporações de texto serão calculadas a partir do argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto negativas pré-computadas do modelo Flan T5. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, negative_prompt_embeds será calculado a partir do argumento de entrada negative_prompt.
  • generated_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-geradas pelo modelo de linguagem GPT2. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entrada prompt.
  • negative_generated_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto negativos pré-gerados pelo modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, o peso do prompt. Se não for fornecido, negative_prompt_embeds será calculado a partir do argumento de entrada negative_prompt.
  • attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos prompt_embeds. Se não for fornecida, a máscara de atenção será calculada a partir do argumento de entrada prompt.
  • negative_attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos negative_prompt_embeds. Se não for fornecida, a máscara de atenção será calculada a partir do argumento de entrada negative_prompt.
  • max_new_tokens (int, opcional, padrão None) — O número de novos tokens a serem gerados com o modelo de linguagem GPT2.

Retorna

prompt_embeds (torch.Tensor)

Text embeddings do modelo Flan T5. attention_mask (torch.LongTensor): Máscara de atenção a ser aplicada aos prompt_embeds. generated_prompt_embeds (torch.Tensor): Text embeddings gerados a partir do modelo de linguagem GPT2.

Codifica o prompt em estados ocultos do codificador de texto.

Exemplo:

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

Parâmetros

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — A sequência usada como prompt para a geração.
  • max_new_tokens (int) — Número de novos tokens a serem gerados.
  • model_kwargs (dict[str, Any], opcional) — Parametrização ad hoc de kwargs adicionais específicos do modelo que serão encaminhados para a função forward do modelo.

Retorna

inputs_embeds (torch.Tensorof shape(batch_size, sequence_length, hidden_size)`)

A sequência de estados ocultos gerados.

Gera uma sequência de hidden-states a partir do modelo de linguagem, condicionada às entradas de embedding.

AudioLDM2ProjectionModel

classe diffusers.AudioLDM2ProjectionModel

< >

( text_encoder_dimtext_encoder_1_dimlangauge_model_dimuse_learned_position_embedding = Nonemax_seq_length = None )

Parâmetros

  • text_encoder_dim (int) — Dimensão dos embeddings de texto do primeiro codificador de texto (CLAP).
  • text_encoder_1_dim (int) — Dimensão dos embeddings de texto do segundo text encoder (T5 ou VITS).
  • langauge_model_dim (int) — Dimensionalidade dos embeddings de texto do modelo de linguagem (GPT2).

Um modelo de projeção linear simples para mapear dois embeddings de texto para um espaço latente compartilhado. Ele também insere vetores de embedding aprendidos no início e no fim de cada sequência de embedding de texto, respectivamente. Cada variável com o sufixo _1 se refere àquela correspondente ao segundo codificador de texto. Caso contrário, é do primeiro.

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

Parâmetros

  • hidden_states (torch.Tensor de forma (batch_size, sequence_length, text_encoder_dim), opcional) — Incorporações de texto do primeiro codificador de texto (CLAP).
  • hidden_states_1 (torch.Tensor de forma (batch_size, sequence_length_1, text_encoder_1_dim), opcional) — Incorporações de texto do segundo codificador de texto (T5 ou VITS).
  • attention_mask (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Máscara de atenção para hidden_states.
  • attention_mask_1 (torch.LongTensor de forma (batch_size, sequence_length_1), opcional) — Máscara de atenção para hidden_states_1.

Retorna

AudioLDM2ProjectionModelOutput

As incorporações de texto projetadas de ambos os codificadores de texto, concatenadas ao longo da dimensão da sequência, e sua máscara de atenção combinada.

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 )

Parâmetros

  • sample_size (int ou tuple[int, int], opcional, padrão None) — Altura e largura da amostra de entrada/saída.
  • in_channels (int, opcional, padrão 4) — Número de canais na amostra de entrada.
  • out_channels (int, opcional, padrão 4) — Número de canais na saída.
  • flip_sin_to_cos (bool, opcional, padrão False) — Se deve inverter o sin para cos no embedding de tempo.
  • freq_shift (int, opcional, padrão 0) — O deslocamento de frequência a ser aplicado ao embedding de tempo.
  • down_block_types (tuple[str], opcional, padrão ("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")) — A tupla de blocos de downsampling a serem usados.
  • mid_block_type (str, opcional, padrão "UNetMidBlock2DCrossAttn") — Tipo de bloco para a parte intermediária do UNet; para AudioLDM2, somente UNetMidBlock2DCrossAttn é permitido.
  • up_block_types (tuple[str], opcional, padrão ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")) — A tupla de blocos de upsample a serem usados.
  • only_cross_attention (bool ou tuple[bool], opcional, padrão False) — Se deve incluir autoatenção nos blocos básicos do transformer, veja BasicTransformerBlock.
  • block_out_channels (tuple[int], opcional, padrão (320, 640, 1280, 1280)) — A tupla de canais de saída para cada bloco.
  • layers_per_block (int, opcional, padrão 2) — O número de camadas por bloco.
  • downsample_padding (int, opcional, padrão 1) — O padding a ser usado para a convolução de downsampling.
  • mid_block_scale_factor (float, opcional, padrão 1.0) — O fator de escala a ser usado para o bloco intermediário.
  • act_fn (str, opcional, padrão "silu") — A função de ativação a ser utilizada.
  • norm_num_groups (int, opcional, padrão 32) — O número de grupos a serem usados para a normalização. Se None, as camadas de normalização e ativação são ignoradas no pós-processamento.
  • norm_eps (float, opcional, padrão 1e-5) — O epsilon a ser usado para a normalização.
  • cross_attention_dim (int ou tuple[int], opcional, padrão 1280) — A dimensão dos recursos de atenção cruzada.
  • transformer_layers_per_block (int ou tuple[int], opcional, padrão 1) — O número de blocos de transformador do tipo BasicTransformerBlock. Relevante apenas para ~models.unet_2d_blocks.CrossAttnDownBlock2D, ~models.unet_2d_blocks.CrossAttnUpBlock2D, ~models.unet_2d_blocks.UNetMidBlock2DCrossAttn.
  • attention_head_dim (int, opcional, padrão 8) — A dimensão dos cabeçalhos de atenção.
  • num_attention_heads (int, opcional) — O número de cabeças de atenção. Se não definido, o valor padrão é attention_head_dim
  • resnet_time_scale_shift (str, opcional, padrão "default") — Configuração de deslocamento de escala de tempo para blocos ResNet (veja ResnetBlock2D). Escolha entre default ou scale_shift.
  • class_embed_type (str, opcional, padrão None) — O tipo de incorporação de classe a ser usado, que é somado às incorporações de tempo. Escolha entre None, "timestep", "identity", "projection" ou "simple_projection".
  • num_class_embeds (int, opcional, padrão None) — Dimensão de entrada da matriz de incorporação aprendível a ser projetada para time_embed_dim, ao realizar condicionamento por classe com class_embed_type igual a None.
  • time_embedding_type (str, opcional, padrão positional) — O tipo de incorporação de posição a ser usado para os passos de tempo. Escolha entre positional ou fourier.
  • time_embedding_dim (int, opcional, padrão None) — Substituição opcional para a dimensão do embedding de tempo projetado.
  • time_embedding_act_fn (str, opcional, padrão None) — Função de ativação opcional para usar apenas uma vez nos embeddings de tempo antes de serem passados para o restante do UNet. Escolha entre silu, mish, gelu e swish.
  • timestep_post_act (str, opcional, padrão None) — A segunda função de ativação a ser usada no embedding de timestep. Escolha entre silu, mish e gelu.
  • time_cond_proj_dim (int, opcional, padrão None) — A dimensão da camada cond_proj no embedding de timestep.
  • conv_in_kernel (int, opcional, padrão 3) — O tamanho do kernel da camada conv_in.
  • conv_out_kernel (int, opcional, padrão 3) — O tamanho do kernel da camada conv_out.
  • projection_class_embeddings_input_dim (int, opcional) — A dimensão da entrada class_labels quando class_embed_type="projection". Obrigatório quando class_embed_type="projection".
  • class_embeddings_concat (bool, opcional, padrão False) — Se as incorporações de tempo devem ser concatenadas com as incorporações de classe.

Um modelo 2D UNet condicional que recebe uma amostra com ruído, um estado condicional e um timestep e retorna uma saída com a forma da amostra. Em comparação com o UNet2DConditionModel padrão, esta variante inclui opcionalmente uma camada adicional de autoatenção em cada bloco Transformer, bem como múltiplas camadas de atenção cruzada. Ela também permite até dois embeddings de atenção cruzada, encoder_hidden_states e encoder_hidden_states_1.

Este modelo herda de ModelMixin. Consulte a documentação da superclasse para seus métodos genéricos implementados para todos os modelos (como download ou salvamento).

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

Parâmetros

  • sample (torch.Tensor) — O tensor de entrada com ruído, com a seguinte forma (batch, channel, height, width).
  • timestep (torch.Tensor ou float ou int) — O número de timesteps para desruidar uma entrada.
  • encoder_hidden_states (torch.Tensor) — Os estados ocultos do codificador com forma (batch, sequence_length, feature_dim).
  • encoder_attention_mask (torch.Tensor) — Uma máscara de atenção cruzada de forma (batch, sequence_length) é aplicada a encoder_hidden_states. Se True, a máscara é mantida; caso contrário, se False, ela é descartada. A máscara será convertida em um viés, que adiciona valores negativos grandes às pontuações de atenção correspondentes aos tokens “descartados”.
  • return_dict (bool, opcional, padrão True) — Se deve ou não retornar um UNet2DConditionOutput em vez de uma tupla simples.
  • cross_attention_kwargs (dict, opcional) — Um dicionário de kwargs que, se especificado, é passado para o AttnProcessor.
  • encoder_hidden_states_1 (torch.Tensor, opcional) — Um segundo conjunto de estados ocultos do codificador com forma (batch, sequence_length_2, feature_dim_2). Pode ser usado para condicionar o modelo em um conjunto diferente de incorporações em relação a encoder_hidden_states.
  • encoder_attention_mask_1 (torch.Tensor, opcional) — Uma máscara de atenção cruzada de forma (batch, sequence_length_2) é aplicada a encoder_hidden_states_1. Se True, a máscara é mantida; caso contrário, se False, ela é descartada. A máscara será convertida em um viés, que adiciona valores negativos grandes às pontuações de atenção correspondentes aos tokens “descartados”.

Retorna

UNet2DConditionOutput ou tuple

Se return_dict for True, um UNet2DConditionOutput é retornado, caso contrário, uma tuple é retornada, onde o primeiro elemento é o tensor da amostra.

O método forward do AudioLDM2UNet2DConditionModel.

AudioPipelineOutput

classe diffusers.AudioPipelineOutput

< >

( audios: ndarray )

Parâmetros

  • audios (np.ndarray) — Lista de amostras de áudio com ruído removido de um array NumPy de forma (batch_size, num_channels, sample_rate).

Classe de saída para pipelines de áudio.

Update on GitHub

←ACE-Step LongCat-AudioDiT→