Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /pipelines /audioldm2.md
mishig
about 4 hours ago
preview code
download
raw
42 kB
# AudioLDM 2

AudioLDM 2 se propuso en [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734) de Haohe Liu et al. AudioLDM 2 toma un prompt de texto como entrada y predice el audio correspondiente. Puede generar efectos de sonido condicionados por texto, habla humana y música.

Inspirado en [Stable Diffusion](./stable_diffusion/overview), AudioLDM 2 es un _modelo de difusión latente (LDM)_ de texto a audio que aprende representaciones de audio continuas a partir de incrustaciones de texto. Se utilizan dos modelos de codificador de texto para calcular las incrustaciones de texto a partir de una entrada de indicación: la rama de texto de [CLAP](https://huggingface.co/docs/transformers/main/en/model_doc/clap) y el codificador de [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5). Estas incrustaciones de texto se proyectan luego a un espacio de incrustación compartido mediante un [AudioLDM2ProjectionModel](./audioldm2#diffusers.AudioLDM2ProjectionModel). Se utiliza un [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2) _modelo de lenguaje (LM)_ para predecir de forma autorregresiva ocho nuevos vectores de incrustación, condicionados a las incrustaciones proyectadas de CLAP y Flan-T5. Los vectores de incrustación generados y las incrustaciones de texto de Flan-T5 se utilizan como condicionamiento de atención cruzada en el LDM. El [UNet](./audioldm2#diffusers.AudioLDM2UNet2DConditionModel) de AudioLDM 2 es único en el sentido de que toma **dos** incrustaciones de atención cruzada, en oposición a un solo condicionamiento de atención cruzada, como en la mayoría de los otros LDMs.

El resumen del artículo es el siguiente:

*Aunque la generación de audio presenta similitudes entre los distintos tipos de audio, como el habla, la música y los efectos de sonido, el diseño de modelos para cada tipo requiere una consideración cuidadosa de objetivos y sesgos específicos que pueden diferir significativamente de los de otros tipos. Para acercarnos a una perspectiva unificada de la generación de audio, este artículo propone un marco que utiliza el mismo método de aprendizaje para la generación de habla, música y efectos de sonido. Nuestro marco introduce una representación general del audio, denominada "lenguaje de audio" (LOA). Cualquier audio puede traducirse a LOA basándose en AudioMAE, un modelo de aprendizaje de representaciones preentrenado de forma auto-supervisada. En el proceso de generación, traducimos cualquier modalidad a LOA utilizando un modelo GPT-2 y realizamos un aprendizaje de generación de audio auto-supervisado con un modelo de difusión latente condicionado en LOA. El marco propuesto aporta de forma natural ventajas como la capacidad de aprendizaje en contexto y la reutilización de los modelos preentrenados auto-supervisados AudioMAE y de difusión latente. Los experimentos en los principales benchmarks de texto a audio, texto a música y texto a habla demuestran un rendimiento de estado del arte o competitivo frente a enfoques anteriores. Nuestro código, modelo preentrenado y demo están disponibles en [este URL de https](https://audioldm.github.io/audioldm2).*

Este pipeline fue aportado por [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) y [Nguyễn Công Tú Anh](https://github.com/tuanh123789). La base de código original se puede encontrar en [haoheliu/audioldm2](https://github.com/haoheliu/audioldm2).

## Consejos

### Elegir un punto de control

AudioLDM2 viene en tres variantes. Dos de estos puntos de control son aplicables a la tarea general de generación de audio a partir de texto. El tercer punto de control se entrena exclusivamente para la generación de música a partir de texto.

Todos los puntos de control comparten el mismo tamaño de modelo para los codificadores de texto y el VAE. Difieren en el tamaño y la profundidad del UNet. Consulte la tabla siguiente para obtener detalles sobre los tres puntos de control:

| Checkpoint                                                      | Tarea          | Tamaño del modelo UNet | Tamaño total del modelo | Datos de entrenamiento / h |
|-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------|
| [audioldm2](https://huggingface.co/cvssp/audioldm2)             | Texto a audio | 350M            | 1.1B             | 1150k             |
| [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | Texto a audio | 750M            | 1.5B             | 1150k             |
| [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | Texto a música | 350M            | 1.1B             | 665k              |
| [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | Texto a voz | 350M            | 1.1B             |10k              |
| [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | Texto a voz | 350M            | 1.1B             |              |

### Construir un prompt

* Los descriptores de entrada funcionan mejor: usa adjetivos para describir el sonido (p. ej., "alta calidad" o "claro") y haz que el descriptor sea específico en su contexto (p. ej., "arroyo de agua en un bosque" en lugar de "arroyo").
* Es mejor usar términos generales como "cat" o "dog" en lugar de nombres específicos u objetos abstractos con los que el modelo podría no estar familiarizado.
* El uso de un **negative prompt** puede mejorar significativamente la calidad de la forma de onda generada, al guiar la generación alejándola de términos que corresponden a audio de baja calidad. Pruebe a usar un negative prompt de "Low quality."

### Control de la inferencia

* La _calidad_ de la muestra de audio predicha se puede controlar mediante el argumento `num_inference_steps`; un mayor número de pasos produce un audio de mayor calidad a costa de una inferencia más lenta.
* La _length_ de la muestra de audio predicha se puede controlar variando el argumento `audio_length_in_s`.

### Evaluación de las formas de onda generadas:

* La calidad de las formas de onda generadas puede variar significativamente según la semilla. Pruebe generando con diferentes semillas hasta encontrar una generación satisfactoria.
* Se pueden generar varias formas de onda de una sola vez: establezca `num_waveforms_per_prompt` en un valor mayor que 1. Se realizará una puntuación automática entre las formas de onda generadas y el texto del prompt, y los audios se clasificarán de mejor a peor en consecuencia.

El siguiente ejemplo demuestra cómo construir una buena generación de música y voz utilizando los consejos mencionados anteriormente: [ejemplo](./audioldm2#diffusers.AudioLDM2Pipeline.__call__.example).

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder ([ClapModel](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapModel)) : Primer codificador de texto congelado. AudioLDM2 utiliza el modelo de incrustación conjunta de audio y texto [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), específicamente la variante [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused). La rama de texto se utiliza para codificar el prompt de texto en una incrustación de prompt. El modelo completo de audio y texto se utiliza para clasificar las formas de onda generadas en relación con el prompt de texto calculando puntuaciones de similitud.
text_encoder_2 ([`~transformers.T5EncoderModel`, `~transformers.VitsModel`]) : Segundo codificador de texto congelado. AudioLDM2 utiliza el codificador de [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [google/flan-t5-large](https://huggingface.co/google/flan-t5-large). Segundo codificador de texto congelado utilizado para TTS. AudioLDM2 utiliza el codificador de [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel).
projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/es/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : Un modelo entrenado que se utiliza para proyectar linealmente los hidden-states de los modelos de codificador de texto primero y segundo e insertar las incorporaciones de tokens SOS y EOS aprendidas. Los hidden-states proyectados de los dos codificadores de texto se concatenan para dar la entrada al modelo de lenguaje. Una incorporación de posición aprendida para los hidden-states de Vits

language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.GPT2Model)) : Un modelo de lenguaje auto-regresivo utilizado para generar una secuencia de hidden-states condicionada en las salidas proyectadas de los dos codificadores de texto.
tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : Tokenizador para tokenizar el texto del primer codificador de texto congelado.
tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : Tokenizador para tokenizar el texto del segundo codificador de texto congelado.

feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : Extractor de características para preprocesar las formas de onda de audio generadas en espectrogramas log-mel para la puntuación automática.
unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de audio codificados.
scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de audio codificados. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler).
vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/main/en/model_doc/speecht5#transformers.SpeechT5HifiGan)) : Vocoder de la clase `SpeechT5HifiGan` para convertir los latentes del mel-espectrograma en la forma de onda de audio final.
Pipeline para la generación de audio a partir de texto usando AudioLDM2.
Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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')
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L844)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de audio. Si no se define, debe pasar `prompt_embeds`.

transcription (`str` o `list[str]`, *opcional*) --\ La transcripción para la conversión de texto a voz.

audio_length_in_s (`int`, *opcional*, valor predeterminado 10.24) : La longitud de la muestra de audio generada en segundos.
num_inference_steps (`int`, *opcional*, valor predeterminado 200) : El número de pasos de desruido. Más pasos de desruido suelen conducir a un audio de mayor calidad a costa de una inferencia más lenta.
guidance_scale (`float`, *opcional*, valor predeterminado 3.5) : Un valor más alto de la escala de guía anima al modelo a generar audio que esté estrechamente vinculado al `prompt` de texto a costa de una menor calidad de sonido. La escala de guía se habilita cuando `guidance_scale > 1`.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de audio. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`).

num_waveforms_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de formas de onda a generar por indicación. Si `num_waveforms_per_prompt > 1`, se realiza una puntuación automática entre las salidas generadas y la indicación de texto. Esta puntuación clasifica las formas de onda generadas en función de su similitud coseno con la entrada de texto en el espacio de incrustación conjunto de texto y audio.

eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de espectrogramas. Se pueden usar para ajustar la misma generación con diferentes indicaciones. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`.

generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se calculará a partir del argumento de entrada `negative_prompt`.

attention_mask (`torch.LongTensor`, *opcional*) : Máscara de atención precalculada que se aplicará a `prompt_embeds`. Si no se proporciona, la máscara de atención se calculará a partir del argumento de entrada `prompt`.

negative_attention_mask (`torch.LongTensor`, *opcional*) : Máscara de atención precalculada que se aplicará a `negative_prompt_embeds`. Si no se proporciona, la máscara de atención se calculará a partir del argumento de entrada `negative_prompt`.

max_new_tokens (`int`, *opcional*, valor predeterminado None) : Número de nuevos tokens que se generarán con el modelo de lenguaje GPT2. Si no se proporciona, el número de tokens se tomará de la configuración del modelo.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.
callback (`Callable`, *opcional*) : Una función que se llama cada `callback_steps` pasos durante la inferencia. La función se llama con los siguientes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, valor predeterminado 1) : La frecuencia con la que se llama a la función `callback`. Si no se especifica, la callback se llama en cada paso.
cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
output_type (`str`, *opcional*, valor predeterminado `"np"`) : El formato de salida del audio generado. Elija entre `"np"` para devolver un `np.ndarray` de NumPy o `"pt"` para devolver un objeto `torch.Tensor` de PyTorch. Establezca `"latent"` para devolver la salida del modelo de difusión latente (LDM).

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con el audio generado.

La función de llamada para el pipeline de generación.

Ejemplos:
```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')
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226)

Descarga todos los modelos a la CPU usando accelerate, reduciendo el uso de memoria con un bajo impacto en el rendimiento. En comparación con `enable_sequential_cpu_offload`, este método mueve un modelo completo a la GPU a la vez cuando se llama a su método `forward`, y el modelo permanece en la GPU hasta que se ejecute el siguiente modelo. El ahorro de memoria es menor que con `enable_sequential_cpu_offload`, pero el rendimiento es mucho mejor debido a la ejecución iterativa de `unet`.

#### encode_prompt[[diffusers.AudioLDM2Pipeline.encode_prompt]]

```python
encode_prompt(prompt, device, num_waveforms_per_prompt, do_classifier_free_guidance, transcription = None, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L331)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

transcription (`str` o `list[str]`) : transcripción de texto a voz

device (`torch.device`) : dispositivo de torch

num_waveforms_per_prompt (`int`) : número de formas de onda que deben generarse por indicación
do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de audio. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto precalculados del modelo Flan T5. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto se calcularán a partir del argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos precalculados del modelo Flan T5. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se calculará a partir del argumento de entrada `negative_prompt`.

generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_generated_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se calculará a partir del argumento de entrada `negative_prompt`.

attention_mask (`torch.LongTensor`, *opcional*) : Máscara de atención precalculada que se aplicará a `prompt_embeds`. Si no se proporciona, la máscara de atención se calculará a partir del argumento de entrada `prompt`.

negative_attention_mask (`torch.LongTensor`, *opcional*) : Máscara de atención precalculada que se aplicará a `negative_prompt_embeds`. Si no se proporciona, la máscara de atención se calculará a partir del argumento de entrada `negative_prompt`.

max_new_tokens (`int`, *opcional*, valor predeterminado None) : El número de nuevos tokens que se generarán con el modelo de lenguaje GPT2.

**Devuelve:** prompt_embeds (`torch.Tensor`)
Embeddings de texto del modelo Flan T5. attention_mask (`torch.LongTensor`): Máscara de atención que se aplicará a `prompt_embeds`. generated_prompt_embeds (`torch.Tensor`): Embeddings de texto generados a partir del modelo de lenguaje GPT2.

Codifica el prompt en estados ocultos del codificador de texto.

Ejemplo:

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L278)

**Parámetros:**

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : La secuencia utilizada como indicación para la generación.

max_new_tokens (`int`) : Número de nuevos tokens a generar.

model_kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de kwargs adicionales específicos del modelo que se reenviarán a la función `forward` del modelo.
**Returns:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`)

La secuencia de estados ocultos generados.

Genera una secuencia de hidden-states desde el modelo de lenguaje, condicionada en las 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60)

**Parámetros:**

text_encoder_dim (`int`) : Dimensionalidad de las incrustaciones de texto del primer codificador de texto (CLAP).

text_encoder_1_dim (`int`) : Dimensionalidad de las incrustaciones de texto del segundo codificador de texto (T5 o VITS).
langauge_model_dim (`int`) : Dimensionalidad de las incrustaciones de texto del modelo de lenguaje (GPT2).
Un modelo de proyección lineal simple para mapear dos incrustaciones de texto a un espacio latente compartido. También inserta vectores de incrustación aprendidos al inicio y al final de cada secuencia de incrustación de texto, respectivamente. Cada variable con el sufijo `_1` se refiere a la correspondiente al segundo codificador de texto. En caso contrario, proviene del primero.

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

[Fuente](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*) : Incrustaciones de texto del primer codificador de texto (CLAP).
hidden_states_1 (`torch.Tensor` de forma `(batch_size, sequence_length_1, text_encoder_1_dim)`, *opcional*) : Incrustaciones de texto del segundo codificador de texto (T5 o VITS).
attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara de atención para `hidden_states`.

attention_mask_1 (`torch.LongTensor` de forma `(batch_size, sequence_length_1)`, *opcional*) : Máscara de atención para `hidden_states_1`.

**Devuelve:** `AudioLDM2ProjectionModelOutput`

Las incrustaciones de texto proyectadas de ambos codificadores de texto, concatenadas a lo largo de la dimensión de secuencia, y su máscara de atención 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[str] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int] = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] = 1, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, class_embeddings_concat: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45)

**Parámetros:**

sample_size (`int` o `tuple[int, int]`, *opcional*, valor predeterminado `None`) : Altura y ancho de la muestra de entrada/salida.
in_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en la muestra de entrada.

out_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en la salida.
flip_sin_to_cos (`bool`, *opcional*, por defecto `False`) : Si se debe invertir el sin a cos en la incrustación temporal.

freq_shift (`int`, *opcional*, valor predeterminado 0) : El desplazamiento de frecuencia que se aplica a la incrustación temporal.
down_block_types (`tuple[str]`, *opcional*, por defecto `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : La tupla de bloques de muestreo descendente a utilizar.
mid_block_type (`str`, *opcional*, valor predeterminado `"UNetMidBlock2DCrossAttn"`) : Tipo de bloque para la parte media de UNet, solo puede ser `UNetMidBlock2DCrossAttn` para AudioLDM2.
up_block_types (`tuple[str]`, *opcional*, por defecto `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : La tupla de bloques de remuestreo ascendente a utilizar.
only_cross_attention (`bool` o `tuple[bool]`, *opcional*, por defecto `False`) : Si se debe incluir autoatención en los bloques básicos de transformer, ver `BasicTransformerBlock`.
block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(320, 640, 1280, 1280)`) : La tupla de canales de salida para cada bloque.
layers_per_block (`int`, *opcional*, valor predeterminado 2) : El número de capas por bloque.
downsample_padding (`int`, *opcional*, valor predeterminado 1) : El relleno a utilizar para la convolución de muestreo descendente.

mid_block_scale_factor (`float`, *opcional*, valor predeterminado 1.0) : El factor de escala a utilizar para el bloque intermedio.
act_fn (`str`, *opcional*, por defecto `"silu"`) : La función de activación a utilizar.

norm_num_groups (`int`, *opcional*, valor predeterminado 32) : El número de grupos a utilizar para la normalización. Si es `None`, se omiten las capas de normalización y activación en el posprocesamiento.

norm_eps (`float`, *opcional*, valor predeterminado 1e-5) : El epsilon a utilizar para la normalización.
cross_attention_dim (`int` o `tuple[int]`, *opcional*, valor predeterminado 1280) : La dimensión de las características de la atención cruzada.
transformer_layers_per_block (`int` o `tuple[int]`, *opcional*, valor predeterminado 1) : El número de bloques de transformador de tipo `BasicTransformerBlock`. Solo es relevante para `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`.

attention_head_dim (`int`, *opcional*, valor predeterminado 8) : La dimensión de las cabezas de atención.

num_attention_heads (`int`, *opcional*) : El número de cabezas de atención. Si no se define, el valor predeterminado es `attention_head_dim`

resnet_time_scale_shift (`str`, *opcional*, valor predeterminado `"default"`) : Configuración de desplazamiento de escala temporal para los bloques ResNet (ver `ResnetBlock2D`). Elija entre `default` o `scale_shift`.

class_embed_type (`str`, *opcional*, valor predeterminado `None`) : El tipo de embedding de clase que se utilizará y que finalmente se suma con los embeddings de tiempo. Elija entre `None`, `"timestep"`, `"identity"`, `"projection"` o `"simple_projection"`.

num_class_embeds (`int`, *opcional*, valor predeterminado `None`) : Dimensión de entrada de la matriz de incrustación aprendible que se proyectará a `time_embed_dim`, al realizar condicionamiento por clase con `class_embed_type` igual a `None`.

time_embedding_type (`str`, *opcional*, valor predeterminado `positional`) : El tipo de incrustación de posición a utilizar para los pasos de tiempo. Elija entre `positional` o `fourier`.

time_embedding_dim (`int`, *opcional*, valor predeterminado `None`) : Un valor opcional para sobrescribir la dimensión del embedding de tiempo proyectado.

time_embedding_act_fn (`str`, *opcional*, valor predeterminado `None`) : Función de activación opcional para usar solo una vez en las incrustaciones de tiempo antes de pasarlas al resto de la UNet. Elija entre `silu`, `mish`, `gelu` y `swish`.
timestep_post_act (`str`, *opcional*, valor predeterminado `None`) : La segunda función de activación a utilizar en la incrustación de paso de tiempo. Elija entre `silu`, `mish` y `gelu`.
time_cond_proj_dim (`int`, *opcional*, valor predeterminado `None`) : La dimensión de la capa `cond_proj` en la incrustación del paso de tiempo.

conv_in_kernel (`int`, *opcional*, valor predeterminado `3`) : El tamaño del kernel de la capa `conv_in`.

conv_out_kernel (`int`, *opcional*, valor predeterminado `3`) : El tamaño del kernel de la capa `conv_out`.

projection_class_embeddings_input_dim (`int`, *opcional*) : La dimensión de la entrada `class_labels` cuando `class_embed_type="projection"`. Obligatorio cuando `class_embed_type="projection"`.

class_embeddings_concat (`bool`, *opcional*, por defecto `False`) : Si se deben concatenar los embeddings de tiempo con los embeddings de clase.

Un modelo UNet 2D condicional que toma una muestra con ruido, un estado condicional y un paso de tiempo, y devuelve una salida con forma de muestra. En comparación con el [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) estándar, esta variante incluye opcionalmente una capa de autoatención adicional en cada bloque Transformer, así como múltiples capas de atención cruzada. También permite hasta dos incrustaciones de atención cruzada, `encoder_hidden_states` y `encoder_hidden_states_1`.

Este modelo hereda de [ModelMixin](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin). Consulta la documentación de la superclase para sus métodos genéricos implementados para todos los modelos (como la descarga o el guardado).

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494)

**Parámetros:**

sample (`torch.Tensor`) : El tensor de entrada con ruido con la siguiente forma `(batch, channel, height, width)`.

timestep (`torch.Tensor` o `float` o `int`) : El número de pasos de tiempo para desruidar una entrada.

encoder_hidden_states (`torch.Tensor`) : Los estados ocultos del codificador con forma `(batch, sequence_length, feature_dim)`.

encoder_attention_mask (`torch.Tensor`) : Una máscara de atención cruzada de forma `(batch, sequence_length)` se aplica a `encoder_hidden_states`. Si es `True`, la máscara se conserva; en caso contrario, si es `False`, se descarta. La máscara se convertirá en un sesgo, que añade valores negativos grandes a las puntuaciones de atención correspondientes a los tokens de "descartar".

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) en lugar de una tupla simple.
cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttnProcessor`.
encoder_hidden_states_1 (`torch.Tensor`, *opcional*) : Un segundo conjunto de estados ocultos del codificador con forma `(batch, sequence_length_2, feature_dim_2)`. Se puede usar para condicionar el modelo con un conjunto de embeddings diferente al de `encoder_hidden_states`.

encoder_attention_mask_1 (`torch.Tensor`, *opcional*) : Una máscara de atención cruzada de forma `(batch, sequence_length_2)` se aplica a `encoder_hidden_states_1`. Si es `True`, la máscara se conserva; en caso contrario, si es `False`, se descarta. La máscara se convertirá en un sesgo, que añade valores negativos grandes a las puntuaciones de atención correspondientes a los tokens de "descartar".

**Devuelve:** [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) o `tuple`

Si `return_dict` es True, se devuelve un [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es el tensor de la muestra.

El método forward de [AudioLDM2UNet2DConditionModel](/docs/diffusers/main/es/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel).

## AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

#### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

```python
diffusers.AudioPipelineOutput(audios: ndarray)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L149)

**Parámetros:**

audios (`np.ndarray`) : Lista de muestras de audio desruidadas de un array de NumPy de forma `(batch_size, num_channels, sample_rate)`.

Clase de salida para las tuberías de audio.
Xet Storage Details

Size:: 42 kB
Xet hash:: 58cc1305de94bbe3a0fab53233d24feaaca37a6eee911109d89539916421cdbe
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.