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

AudioLDM 2

AudioLDM 2 se propuso en AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining 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, 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 y el codificador de Flan-T5. Estas incrustaciones de texto se proyectan luego a un espacio de incrustación compartido mediante un AudioLDM2ProjectionModel. Se utiliza un 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 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.

Este pipeline fue aportado por sanchit-gandhi y Nguyễn Công Tú Anh. La base de código original se puede encontrar en 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	Texto a audio	350M	1.1B	1150k
audioldm2-large	Texto a audio	750M	1.5B	1150k
audioldm2-music	Texto a música	350M	1.1B	665k
audioldm2-gigaspeech	Texto a voz	350M	1.1B	10k
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.

Asegúrate de consultar la guía de Schedulers para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección reutilizar componentes entre pipelines para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

diffusers.AudioLDM2Pipeline(vae: AutoencoderKL, text_encoder: ClapModel, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.vits.modeling_vits.VitsModel, projection_model: AudioLDM2ProjectionModel, language_model: GPT2LMHeadModel, tokenizer: RobertaTokenizer, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.vits.tokenization_vits.VitsTokenizer, feature_extractor: ClapFeatureExtractor, unet: AudioLDM2UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vocoder: SpeechT5HifiGan)

Fuente

Parámetros:

vae (AutoencoderKL) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (ClapModel) : Primer codificador de texto congelado. AudioLDM2 utiliza el modelo de incrustación conjunta de audio y texto CLAP, específicamente la variante 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, específicamente la variante google/flan-t5-large. Segundo codificador de texto congelado utilizado para TTS. AudioLDM2 utiliza el codificador de Vits.

projection_model (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) : 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) : 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) : 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) : Un UNet2DConditionModel para desruidar los latentes de audio codificados.

scheduler (SchedulerMixin) : Un scheduler para usar en combinación con unet para desruidar los latentes de audio codificados. Puede ser uno de DDIMScheduler, LMSDiscreteScheduler o PNDMScheduler.

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

__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

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. Solo se aplica al DDIMScheduler y se ignora en otros programadores.

generator (torch.Generator o list[torch.Generator], opcional) : Un torch.Generator 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 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.

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

Si return_dict es True, se devuelve 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:

>>> import scipy
>>> import torch
>>> from diffusers import AudioLDM2Pipeline

>>> repo_id = "cvssp/audioldm2"
>>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16)
>>> pipe = pipe.to("cuda")

>>> # define the prompts
>>> prompt = "The sound of a hammer hitting a wooden surface."
>>> negative_prompt = "Low quality."

>>> # set the seed for generator
>>> generator = torch.Generator("cuda").manual_seed(0)

>>> # run the generation
>>> audio = pipe(
...     prompt,
...     negative_prompt=negative_prompt,
...     num_inference_steps=200,
...     audio_length_in_s=10.0,
...     num_waveforms_per_prompt=3,
...     generator=generator,
... ).audios

>>> # save the best audio sample (index 0) as a .wav file
>>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio[0])

#Using AudioLDM2 for Text To Speech
>>> import scipy
>>> import torch
>>> from diffusers import AudioLDM2Pipeline

>>> repo_id = "anhnct/audioldm2_gigaspeech"
>>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16)
>>> pipe = pipe.to("cuda")

>>> # define the prompts
>>> prompt = "A female reporter is speaking"
>>> transcript = "wish you have a good day"

>>> # set the seed for generator
>>> generator = torch.Generator("cuda").manual_seed(0)

>>> # run the generation
>>> audio = pipe(
...     prompt,
...     transcription=transcript,
...     num_inference_steps=200,
...     audio_length_in_s=10.0,
...     num_waveforms_per_prompt=2,
...     generator=generator,
...     max_new_tokens=512,          #Must set max_new_tokens equa to 512 for TTS
... ).audios

>>> # save the best audio sample (index 0) as a .wav file
>>> scipy.io.wavfile.write("tts.wav", rate=16000, data=audio[0])

enable_model_cpu_offload[[diffusers.AudioLDM2Pipeline.enable_model_cpu_offload]]

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

Fuente

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

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

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:

>>> import scipy
>>> import torch
>>> from diffusers import AudioLDM2Pipeline

>>> repo_id = "cvssp/audioldm2"
>>> pipe = AudioLDM2Pipeline.from_pretrained(repo_id, torch_dtype=torch.float16)
>>> pipe = pipe.to("cuda")

>>> # Get text embedding vectors
>>> prompt_embeds, attention_mask, generated_prompt_embeds = pipe.encode_prompt(
...     prompt="Techno music with a strong, upbeat tempo and high melodic riffs",
...     device="cuda",
...     do_classifier_free_guidance=True,
... )

>>> # Pass text embeddings to pipeline for text-conditional audio generation
>>> audio = pipe(
...     prompt_embeds=prompt_embeds,
...     attention_mask=attention_mask,
...     generated_prompt_embeds=generated_prompt_embeds,
...     num_inference_steps=200,
...     audio_length_in_s=10.0,
... ).audios[0]

>>> # save generated audio sample
>>> scipy.io.wavfile.write("techno.wav", rate=16000, data=audio)

generate_language_model[[diffusers.AudioLDM2Pipeline.generate_language_model]]

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

Fuente

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

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

Fuente

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

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

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

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

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

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

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

Si return_dict es True, se devuelve un UNet2DConditionOutput; en caso contrario, se devuelve una tuple cuyo primer elemento es el tensor de la muestra.

El método forward de AudioLDM2UNet2DConditionModel.

AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput(audios: ndarray)

Fuente

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.