# AudioLDM 2 O AudioLDM 2 foi proposto em [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734) 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](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/overview), 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](https://huggingface.co/docs/transformers/main/en/model_doc/clap) e o codificador do [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5). Esses embeddings de texto são então projetados para um espaço de embeddings compartilhado por um [AudioLDM2ProjectionModel](https://huggingface.co/docs/diffusers/main/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel). Um [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/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](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel) 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 de "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](https://audioldm.github.io/audioldm2).* Este pipeline foi contribuído por [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) e [Nguyễn Công Tú Anh](https://github.com/tuanh123789). A base de código original pode ser encontrada em [haoheliu/audioldm2](https://github.com/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. Consulte a tabela abaixo para obter detalhes sobre os três checkpoints: | Checkpoint | Tarefa | Tamanho do Modelo UNet | Tamanho Total do Modelo | Dados de Treinamento / h | |-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------| | [audioldm2](https://huggingface.co/cvssp/audioldm2) | Texto para áudio | 350M | 1.1B | 1150k | | [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | Texto para áudio | 750M | 1.5B | 1150k | | [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | Texto para música | 350M | 1.1B | 665k | | [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | Texto para fala | 350M | 1.1B |10k | | [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | Texto para fala | 350M | 1.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](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2Pipeline.__call__.example). > [!TIP] > Certifique-se de consultar o [guia](../../using-diffusers/schedulers) 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](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines. ## AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] #### diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] ```python diffusers.AudioLDM2Pipeline(vae: AutoencoderKL, text_encoder: ClapModel, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.vits.modeling_vits.VitsModel, projection_model: AudioLDM2ProjectionModel, language_model: GPT2LMHeadModel, tokenizer: RobertaTokenizer, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.vits.tokenization_vits.VitsTokenizer, feature_extractor: ClapFeatureExtractor, unet: AudioLDM2UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vocoder: SpeechT5HifiGan) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150) **Parâmetros:** vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder ([ClapModel](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapModel)) : Primeiro text-encoder congelado. O AudioLDM2 usa o modelo de incorporação conjunta de áudio e texto [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), especificamente a variante [laion/clap-htsat-unfused](https://huggingface.co/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 ranquear os waveforms gerados 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](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/flan-t5-large](https://huggingface.co/google/flan-t5-large). Segundo codificador de texto congelado usado para TTS. O AudioLDM2 usa o codificador do [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel). projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/pt/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : Um modelo treinado usado para projetar linearmente os hidden-states dos modelos de codificador de texto primeiro e segundo e inserir embeddings aprendidos de tokens SOS e EOS. Os hidden-states projetados dos dois codificadores de texto são concatenados para fornecer a entrada para o modelo de linguagem. Um Position Embedding aprendido para os hidden-states do Vits language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.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](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : Tokenizador para tokenizar o texto para o primeiro text-encoder congelado. tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : Tokenizer para tokenizar o texto para o segundo text-encoder congelado. feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : Extrator de recursos para pré-processar formas de onda de áudio geradas em espectrogramas log-mel para pontuação automática. unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Um `UNet2DConditionModel` para desruidar os latentes de áudio codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes de áudio codificados. Pode ser um de [DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/main/pt/api/schedulers/pndm#diffusers.PNDMScheduler). vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/main/en/model_doc/speecht5#transformers.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](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.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__[[diffusers.AudioLDM2Pipeline.__call__]] ```python __call__(prompt: str | list[str] = None, transcription: str | list[str] = None, audio_length_in_s: float | None = None, num_inference_steps: int = 200, guidance_scale: float = 3.5, negative_prompt: str | list[str] | None = None, num_waveforms_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None, return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int | None = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, output_type: str | None = 'np') ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L842) **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*) --\ O texto para conversão em 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, às custas 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 `prompt` de texto, 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, você precisa 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](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *opcional*) : Emojis de texto pré-gerados a partir do modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embebings de texto negativos pré-gerados a partir do modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. 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](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) em vez de uma tupla simples. callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas 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`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple` Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com o áudio gerado. A função de chamada do pipeline para geração. Exemplos: ```py >>> import scipy >>> import torch >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "cvssp/audioldm2" >>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16) >>> pipe = pipe.to("cuda") >>> # define the prompts >>> prompt = "The sound of a hammer hitting a wooden surface." >>> negative_prompt = "Low quality." >>> # set the seed for generator >>> generator = torch.Generator("cuda").manual_seed(0) >>> # run the generation >>> audio = pipe( ... prompt, ... negative_prompt=negative_prompt, ... num_inference_steps=200, ... audio_length_in_s=10.0, ... num_waveforms_per_prompt=3, ... generator=generator, ... ).audios >>> # save the best audio sample (index 0) as a .wav file >>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio[0]) ``` ``` #Using AudioLDM2 for Text To Speech >>> import scipy >>> import torch >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "anhnct/audioldm2_gigaspeech" >>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16) >>> pipe = pipe.to("cuda") >>> # define the prompts >>> prompt = "A female reporter is speaking" >>> transcript = "wish you have a good day" >>> # set the seed for generator >>> generator = torch.Generator("cuda").manual_seed(0) >>> # run the generation >>> audio = pipe( ... prompt, ... transcription=transcript, ... num_inference_steps=200, ... audio_length_in_s=10.0, ... num_waveforms_per_prompt=2, ... generator=generator, ... max_new_tokens=512, #Must set max_new_tokens equa to 512 for TTS ... ).audios >>> # save the best audio sample (index 0) as a .wav file >>> scipy.io.wavfile.write("tts.wav", rate=16000, data=audio[0]) ``` #### enable_model_cpu_offload[[diffusers.AudioLDM2Pipeline.enable_model_cpu_offload]] ```python enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = 'cuda') ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226) 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[[diffusers.AudioLDM2Pipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_waveforms_per_prompt, do_classifier_free_guidance, transcription = None, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L329) **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 ou não usar classifier free guidance 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 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*) : Embutidos de texto pré-computados do modelo Flan T5. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embutidos de texto serão computados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-computados do modelo Flan T5. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será calculado a partir do argumento de entrada `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *opcional*) : Emojis de texto pré-gerados a partir do modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embebings de texto negativos pré-gerados a partir do modelo de linguagem GPT2. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. 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: ```python >>> import scipy >>> import torch >>> from diffusers import AudioLDM2Pipeline >>> repo_id = "cvssp/audioldm2" >>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16) >>> pipe = pipe.to("cuda") >>> # Get text embedding vectors >>> prompt_embeds, attention_mask, generated_prompt_embeds = pipe.encode_prompt( ... prompt="Techno music with a strong, upbeat tempo and high melodic riffs", ... device="cuda", ... do_classifier_free_guidance=True, ... ) >>> # Pass text embeddings to pipeline for text-conditional audio generation >>> audio = pipe( ... prompt_embeds=prompt_embeds, ... attention_mask=attention_mask, ... generated_prompt_embeds=generated_prompt_embeds, ... num_inference_steps=200, ... audio_length_in_s=10.0, ... ).audios[0] >>> # save generated audio sample >>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio) ``` #### generate_language_model[[diffusers.AudioLDM2Pipeline.generate_language_model]] ```python generate_language_model(inputs_embeds: Tensor = None, max_new_tokens: int = 8, **model_kwargs) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L276) **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. **Returns:** `inputs_embeds (`torch.Tensor` of 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[[diffusers.AudioLDM2ProjectionModel]] #### diffusers.AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]] ```python diffusers.AudioLDM2ProjectionModel(text_encoder_dim, text_encoder_1_dim, langauge_model_dim, use_learned_position_embedding = None, max_seq_length = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60) **Parâmetros:** text_encoder_dim (`int`) : Dimensionalidade dos embeddings de texto do primeiro codificador de texto (CLAP). text_encoder_1_dim (`int`) : Dimensionalidade dos embeddings de texto do segundo codificador de texto (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[[diffusers.AudioLDM2ProjectionModel.forward]] ```python forward(hidden_states: typing.Optional[torch.Tensor] = None, hidden_states_1: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, attention_mask_1: typing.Optional[torch.LongTensor] = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L104) **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[[diffusers.AudioLDM2UNet2DConditionModel]] #### diffusers.AudioLDM2UNet2DConditionModel[[diffusers.AudioLDM2UNet2DConditionModel]] ```python diffusers.AudioLDM2UNet2DConditionModel(sample_size: int | None = None, in_channels: int = 4, out_channels: int = 4, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] = 1, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, class_embeddings_concat: bool = False) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45) **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 o meio do UNet, pode ser apenas `UNetMidBlock2DCrossAttn` para AudioLDM2. 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 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 embedding de classe a ser usado, que é somado aos embeddings 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 de 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`) : Uma 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 da 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 incorporamento de passo de tempo. 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 deve concatenar os embeddings de tempo com os embeddings 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](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel) padrão, esta variante inclui opcionalmente uma camada adicional de autoatenção em cada bloco Transformer, além de 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](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin). Consulte a documentação da superclasse para seus métodos genéricos implementados para todos os modelos (como download ou salvamento). #### forward[[diffusers.AudioLDM2UNet2DConditionModel.forward]] ```python forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True, encoder_hidden_states_1: typing.Optional[torch.Tensor] = None, encoder_attention_mask_1: typing.Optional[torch.Tensor] = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494) **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 a 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](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.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 de "descarte". **Retorna:** [UNet2DConditionOutput](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) ou `tuple` Se `return_dict` for True, um [UNet2DConditionOutput](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é o tensor da amostra. O método forward do [AudioLDM2UNet2DConditionModel](/docs/diffusers/main/pt/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel). ## AudioPipelineOutput[[diffusers.AudioPipelineOutput]] #### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]] ```python diffusers.AudioPipelineOutput(audios: ndarray) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L149) **Parâmetros:** audios (`np.ndarray`) : Lista de amostras de áudio desruídas de um array NumPy de forma `(batch_size, num_channels, sample_rate)`. Classe de saída para pipelines de áudio.