Stable Audio

Stable Audio se propuso en Stable Audio Open por Zach Evans et al. . Toma un prompt de texto como entrada y predice la muestra de sonido o música correspondiente.

Stable Audio Open genera audio estéreo de longitud variable (hasta 47 s) a 44,1 kHz a partir de indicaciones de texto. Está compuesto por tres componentes: un autoencoder que comprime las formas de onda en una longitud de secuencia manejable, un incrustado de texto basado en T5 para la condicionamiento de texto y un modelo de difusión basado en un transformador (DiT) que opera en el espacio latente del autoencoder.

Stable Audio se entrena con un corpus de aproximadamente 48k grabaciones de audio, de las cuales alrededor de 47k provienen de Freesound y el resto del Free Music Archive (FMA). Todos los archivos de audio están licenciados bajo CC0, CC BY o CC Sampling+. Estos datos se utilizan para entrenar el autoencoder y el DiT.

El resumen del artículo es el siguiente: Los modelos generativos abiertos son de vital importancia para la comunidad, ya que permiten realizar ajustes finos y sirven como líneas base al presentar nuevos modelos. Sin embargo, la mayoría de los modelos actuales de texto a audio son privados y no están accesibles para que artistas e investigadores construyan sobre ellos. Aquí describimos la arquitectura y el proceso de entrenamiento de un nuevo modelo de texto a audio de pesos abiertos, entrenado con datos de Creative Commons. Nuestra evaluación muestra que el rendimiento del modelo es competitivo con el estado del arte en diversas métricas. Notablemente, los resultados de FDopenl3 reportados (que miden el realismo de las generaciones) muestran su potencial para la síntesis de sonido estéreo de alta calidad a 44.1kHz.

Este pipeline fue aportado por Yoach Lacombe. La base de código original se puede encontrar en Stability-AI/stable-audio-tools.

Consejos

Al construir un prompt, ten en cuenta:

Los descriptores de entrada funcionan mejor; usa adjetivos para describir el sonido (por ejemplo, “alta calidad” o “claro”) y haz que el descriptor sea específico en el contexto cuando sea posible (por ejemplo, “techno melódico con un ritmo rápido y sintetizadores” funciona mejor que “techno”).
El uso de un negative prompt puede mejorar significativamente la calidad del audio generado. Pruebe a usar un negative prompt de “low quality, average quality”.

Durante la inferencia:

La calidad de la muestra de audio generada 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.
Se pueden generar varias formas de onda de una sola vez: establezca num_waveforms_per_prompt en un valor mayor que 1 para habilitarlo. 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.

Cuantización

La cuantización ayuda a reducir los requisitos de memoria de los modelos muy grandes almacenando los pesos del modelo en un tipo de datos de menor precisión. Sin embargo, la cuantización puede tener un impacto variable en la calidad del vídeo dependiendo del modelo de vídeo.

Consulte el resumen de Quantization para obtener más información sobre los backends de cuantización admitidos y la selección de un backend de cuantización que admita su caso de uso. El siguiente ejemplo demuestra cómo cargar un StableAudioPipeline cuantizado para inferencia con bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, StableAudioDiTModel, StableAudioPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = StableAudioDiTModel.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = StableAudioPipeline.from_pretrained(
    "stabilityai/stable-audio-open-1.0",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "The sound of a hammer hitting a wooden surface."
negative_prompt = "Low quality."
audio = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=200,
    audio_end_in_s=10.0,
    num_waveforms_per_prompt=3,
    generator=generator,
).audios

output = audio[0].T.float().cpu().numpy()
sf.write("hammer.wav", output, pipeline.vae.sampling_rate)

StableAudioPipeline

clase diffusers.StableAudioPipeline

< source >

( vae: AutoencoderOoblecktext_encoder: T5EncoderModelprojection_model: StableAudioProjectionModeltokenizer: T5Tokenizertransformer: StableAudioDiTModelscheduler: EDMDPMSolverMultistepScheduler )

Parámetros

vae (AutoencoderOobleck) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (T5EncoderModel) — Codificador de texto congelado. StableAudio utiliza el codificador de T5, específicamente la variante google-t5/t5-base.
projection_model (StableAudioProjectionModel) — Un modelo entrenado que se utiliza para proyectar linealmente los hidden-states del modelo de codificador de texto y los segundos de inicio y fin. Los hidden-states proyectados del codificador y los segundos condicionales se concatenan para dar como entrada al modelo transformer.
tokenizer (T5Tokenizer) — Tokenizer para tokenizar el texto del codificador de texto congelado.
transformer (StableAudioDiTModel) — Un StableAudioDiTModel para desruidar los latentes de audio codificados.
scheduler (EDMDPMSolverMultistepScheduler) — Un scheduler para usar en combinación con transformer para desruidar los latentes de audio codificados.

Pipeline para la generación de audio a partir de texto usando StableAudio.

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

< source >

( prompt: str | list[str] = Noneaudio_end_in_s: float | None = Noneaudio_start_in_s: float | None = 0.0num_inference_steps: int = 100guidance_scale: float = 7.0negative_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] = Noneinitial_audio_waveforms: typing.Optional[torch.Tensor] = Noneinitial_audio_sampling_rate: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonenegative_attention_mask: typing.Optional[torch.LongTensor] = Nonereturn_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int | None = 1output_type: str | None = 'pt' ) → 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.
audio_end_in_s (float, opcional, valor predeterminado 47.55) — Índice final del audio en segundos.
audio_start_in_s (float, opcional, valor predeterminado 0) — Índice de inicio del audio en segundos.
num_inference_steps (int, opcional, valor predeterminado 100) — 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 7.0) — 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 que se generarán por indicación.
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, para usarse como entradas para la generación de audio. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se genera un tensor de latentes mediante muestreo usando el generator aleatorio suministrado.
initial_audio_waveforms (torch.Tensor, opcional) — Formas de onda de audio iniciales opcionales para usar como forma de onda de audio inicial para la generación. Debe tener la forma (batch_size, num_channels, audio_length) o (batch_size, audio_length), donde batch_size corresponde al número de prompts pasados al modelo.
initial_audio_sampling_rate (int, opcional) — Tasa de muestreo de las initial_audio_waveforms, si se proporcionan. Debe ser la misma que la del modelo.
prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto precalculadas del modelo codificador de texto. 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 calcularán a partir del argumento de entrada prompt.
negative_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativas precalculadas del modelo codificador de texto. 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.
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_text_audio_duration_embeds.
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.
output_type (str, opcional, valor predeterminado "pt") — 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
>>> import soundfile as sf
>>> from diffusers import StableAudioPipeline

>>> repo_id = "stabilityai/stable-audio-open-1.0"
>>> pipe = StableAudioPipeline.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_end_in_s=10.0,
...     num_waveforms_per_prompt=3,
...     generator=generator,
... ).audios

>>> output = audio[0].T.float().cpu().numpy()
>>> sf.write("hammer.wav", output, pipe.vae.sampling_rate)

Update on GitHub