Hugging Face's logo

Diffusers documentation

AudioLDM 2

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

and get access to the augmented documentation experience

to get started

AudioLDM 2

AudioLDM 2 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 ventajas naturales, 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:

CheckpointTareaTamaño del modelo UNetTamaño total del modeloDatos de entrenamiento / h
audioldm2Texto a audio350M1.1B1150k
audioldm2-largeTexto a audio750M1.5B1150k
audioldm2-musicTexto a música350M1.1B665k
audioldm2-gigaspeechTexto a voz350M1.1B10k
audioldm2-ljspeechTexto a voz350M1.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

clase diffusers.AudioLDM2Pipeline

< >

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

Parámetros

  • vae (AutoencoderKL) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes a partir de y hacia 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. El segundo codificador de texto congelado se utiliza 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 Learned Position Embedding 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) — Tokenizer para tokenizar el texto del primer text-encoder congelado.
  • tokenizer_2 ([~transformers.T5Tokenizer, ~transformers.VitsTokenizer]) — Tokenizer para tokenizar el texto del segundo text-encoder 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__

< >

( prompt: str | list[str] = Nonetranscription: str | list[str] = Noneaudio_length_in_s: float | None = Nonenum_inference_steps: int = 200guidance_scale: float = 3.5negative_prompt: str | list[str] | None = Nonenum_waveforms_per_prompt: int | None = 1eta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonegenerated_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_generated_prompt_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonenegative_attention_mask: typing.Optional[torch.LongTensor] = Nonemax_new_tokens: int | None = Nonereturn_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int | None = 1cross_attention_kwargs: dict[str, typing.Any] | None = Noneoutput_type: str | None = 'np' ) → StableDiffusionPipelineOutput or tuple

Parámetros

  • prompt (str o list[str], opcional) — El prompt o 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 síntesis de voz.
  • audio_length_in_s (int, opcional, valor predeterminado 10.24) — La duración 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 de escala de guía más alto anima al modelo a generar audio estrechamente vinculado al texto prompt 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 prompts para guiar lo que no debe incluirse en la generación de audio. Si no se define, es necesario 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 que la generación sea determinista.
  • latents (torch.Tensor, opcional) — Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación del espectrograma. Se pueden usar para ajustar la misma generación con diferentes prompts. 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) — Incrustaciones de texto negativo pregeneradas. 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) — Incrustaciones de texto pregeneradas del modelo de lenguaje GPT2. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
  • negative_generated_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, 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

< >

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

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

< >

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

Parámetros

  • prompt (str 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 classifier free guidance o no
  • 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) — Incrustaciones de texto precalculadas del modelo Flan T5. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, las incrustaciones de texto se calcularán a partir del argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativo precalculadas del modelo Flan T5. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se calculará a partir del argumento de entrada negative_prompt.
  • generated_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto pregeneradas del modelo de lenguaje GPT2. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
  • negative_generated_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas del modelo de lenguaje GPT2. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, 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

< >

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

Parámetros

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — 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.

Devuelve

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

clase diffusers.AudioLDM2ProjectionModel

< >

( text_encoder_dimtext_encoder_1_dimlangauge_model_dimuse_learned_position_embedding = Nonemax_seq_length = None )

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

< >

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

Parámetros

  • hidden_states (torch.Tensor de forma (batch_size, sequence_length, text_encoder_dim), opcional) — 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

clase diffusers.AudioLDM2UNet2DConditionModel

< >

( sample_size: int | None = Nonein_channels: int = 4out_channels: int = 4flip_sin_to_cos: bool = Truefreq_shift: int = 0down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D')mid_block_type: str = 'UNetMidBlock2DCrossAttn'up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D')only_cross_attention: bool | tuple[bool] = Falseblock_out_channels: tuple = (320, 640, 1280, 1280)layers_per_block: int | tuple[int] = 2downsample_padding: int = 1mid_block_scale_factor: float = 1act_fn: str = 'silu'norm_num_groups: int | None = 32norm_eps: float = 1e-05cross_attention_dim: int | tuple[int] = 1280transformer_layers_per_block: int | tuple[int] = 1attention_head_dim: int | tuple[int] = 8num_attention_heads: int | tuple[int] | None = Noneuse_linear_projection: bool = Falseclass_embed_type: str | None = Nonenum_class_embeds: int | None = Noneupcast_attention: bool = Falseresnet_time_scale_shift: str = 'default'time_embedding_type: str = 'positional'time_embedding_dim: int | None = Nonetime_embedding_act_fn: str | None = Nonetimestep_post_act: str | None = Nonetime_cond_proj_dim: int | None = Noneconv_in_kernel: int = 3conv_out_kernel: int = 3projection_class_embeddings_input_dim: int | None = Noneclass_embeddings_concat: bool = False )

Parámetros

  • sample_size (int o tuple[int, int], opcional, valor predeterminado None) — Altura y anchura 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, valor predeterminado False) — Si se debe invertir el sin a cos en el embedding temporal.
  • freq_shift (int, opcional, valor predeterminado 0) — El desplazamiento de frecuencia que se aplicará 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 central de UNet; solo puede ser UNetMidBlock2DCrossAttn en 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, valor predeterminado False) — Si se debe incluir la autoatención en los bloques básicos de transformer, ver BasicTransformerBlock.
  • block_out_channels (tuple[int], opcional, por defecto (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 reducción de muestreo.
  • 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 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 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 de tiempo para los bloques ResNet (ver ResnetBlock2D). Elija entre default o scale_shift.
  • class_embed_type (str, opcional, valor predeterminado None) — El tipo de incrustación de clase que se utilizará y que finalmente se suma a las incrustaciones 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 que se 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, valor predeterminado False) — Si se deben concatenar las incrustaciones de tiempo con las incrustaciones 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 clase superior para sus métodos genéricos implementados para todos los modelos (como la descarga o el guardado).

forward

< >

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

Parámetros

  • sample (torch.Tensor) — 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 True, la máscara se conserva; en caso contrario, si 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 “descartados”.
  • 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). Puede utilizarse para condicionar el modelo con un conjunto diferente de incrustaciones respecto a 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 “descartados”.

Devuelve

UNet2DConditionOutput o tuple

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

El método forward de AudioLDM2UNet2DConditionModel.

AudioPipelineOutput

clase diffusers.AudioPipelineOutput

< >

( audios: ndarray )

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.

Update on GitHub

←ACE-Step LongCat-AudioDiT→