Hugging Face's logo

Diffusers documentation

Stable Audio

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Stable Audio

Stable Audio foi proposto em Stable Audio Open por Zach Evans et al. . Ele recebe um prompt de texto como entrada e prevê a amostra de som ou música correspondente.

Stable Audio Open gera áudio estéreo de comprimento variável (até 47s) a 44.1kHz a partir de prompts de texto. Ele compreende três componentes: um autoencoder que comprime formas de onda em um comprimento de sequência gerenciável, um embedding de texto baseado em T5 para condicionamento de texto e um modelo de difusão baseado em transformer (DiT) que opera no espaço latente do autoencoder.

O Stable Audio é treinado em um corpus de aproximadamente 48 mil gravações de áudio, das quais cerca de 47 mil são do Freesound e o restante do Free Music Archive (FMA). Todos os arquivos de áudio são licenciados sob CC0, CC BY ou CC Sampling+. Esses dados são usados para treinar o autoencoder e o DiT.

O resumo do artigo é o seguinte: Os modelos generativos abertos são de vital importância para a comunidade, permitindo o ajuste fino e servindo como linhas de base ao apresentar novos modelos. No entanto, a maioria dos modelos atuais de texto para áudio são privados e não acessíveis para artistas e pesquisadores construírem sobre eles. Aqui, descrevemos a arquitetura e o processo de treinamento de um novo modelo de texto para áudio com pesos abertos, treinado com dados Creative Commons. Nossa avaliação mostra que o desempenho do modelo é competitivo com o estado da arte em diversas métricas. Notavelmente, os resultados FDopenl3 relatados (que medem o realismo das gerações) demonstram seu potencial para síntese de som estéreo de alta qualidade a 44,1 kHz.

Este pipeline foi contribuído por Yoach Lacombe. A base de código original pode ser encontrada em Stability-AI/stable-audio-tools.

Dicas

Ao construir um prompt, tenha em mente:

  • Entradas de prompt descritivas funcionam melhor; use adjetivos para descrever o som (por exemplo, “high quality” ou “clear”) e torne o prompt específico ao contexto sempre que possível (por exemplo, “melodic techno with a fast beat and synths” funciona melhor do que “techno”).
  • O uso de um prompt negativo pode melhorar significativamente a qualidade do áudio gerado. Tente usar um prompt negativo de “low quality, average quality”.

Durante a inferência:

  • A qualidade da amostra de áudio gerada pode ser controlada pelo argumento num_inference_steps; um número maior de etapas resulta em áudio de maior qualidade, porém com inferência mais lenta.
  • Várias formas de onda podem ser geradas de uma só vez: defina num_waveforms_per_prompt para um valor maior que 1 para habilitar. A pontuação automática será realizada entre as formas de onda geradas e o texto do prompt, e os áudios serão ranqueados do melhor para o pior de acordo com isso.

Quantização

A quantização ajuda a reduzir os requisitos de memória de modelos muito grandes armazenando os pesos do modelo em um tipo de dados de menor precisão. No entanto, a quantização pode ter um impacto variável na qualidade do vídeo, dependendo do modelo de vídeo.

Consulte a visão geral de Quantization para saber mais sobre os backends de quantização suportados e sobre como selecionar um backend de quantização que atenda ao seu caso de uso. O exemplo abaixo demonstra como carregar um StableAudioPipeline quantizado para inferência com 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

classe diffusers.StableAudioPipeline

< >

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

Parâmetros

  • vae (AutoencoderOobleck) — Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens a partir de e para representações latentes.
  • text_encoder (T5EncoderModel) — Codificador de texto congelado. O StableAudio usa o codificador do T5, especificamente a variante google-t5/t5-base.
  • projection_model (StableAudioProjectionModel) — Um modelo treinado usado para projetar linearmente os hidden-states do modelo de codificador de texto e os segundos de início e fim. Os hidden-states projetados do codificador e os segundos condicionais são concatenados para fornecer a entrada para o modelo transformer.
  • tokenizer (T5Tokenizer) — Tokenizer para tokenizar o texto para o text-encoder congelado.
  • transformer (StableAudioDiTModel) — Um StableAudioDiTModel para desruidar os latentes de áudio codificados.
  • scheduler (EDMDPMSolverMultistepScheduler) — Um scheduler a ser usado em combinação com transformer para desruidar os latentes de áudio codificados.

Pipeline para geração de texto para áudio usando StableAudio.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

__call__

< >

( 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 ou list[str], opcional) — O prompt ou os prompts para orientar a geração de áudio. Se não definido, você precisa passar prompt_embeds.
  • audio_end_in_s (float, opcional, padrão 47.55) — Índice de fim do áudio em segundos.
  • audio_start_in_s (float, opcional, padrão 0) — Índice de início do áudio em segundos.
  • num_inference_steps (int, opcional, padrão 100) — O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em um áudio de maior qualidade, à custa de uma inferência mais lenta.
  • guidance_scale (float, opcional, padrão 7.0) — Um valor mais alto de guidance scale incentiva o modelo a gerar áudio que esteja intimamente ligado ao texto prompt, em detrimento de uma menor qualidade sonora. O guidance scale é ativado quando guidance_scale > 1.
  • negative_prompt (str ou list[str], opcional) — O prompt ou os prompts para orientar o que não incluir na geração de áudio. Se não definido, é necessário passar negative_prompt_embeds em vez disso. Ignorado quando não está usando orientação (guidance_scale < 1).
  • num_waveforms_per_prompt (int, opcional, padrão 1) — O número de formas de onda a serem geradas por prompt.
  • eta (float, opcional, padrão 0.0) — Corresponde ao parâmetro eta (η) do paper DDIM. Aplica-se apenas ao DDIMScheduler e é ignorado em outros schedulers.
  • generator (torch.Generator ou list[torch.Generator], opcional) — Um torch.Generator para tornar a geração determinística.
  • latents (torch.Tensor, opcional) — Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de áudio. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o generator aleatório fornecido.
  • initial_audio_waveforms (torch.Tensor, opcional) — Formas de onda de áudio iniciais opcionais para usar como a forma de onda de áudio inicial para a geração. Deve ter a forma (batch_size, num_channels, audio_length) ou (batch_size, audio_length), onde batch_size corresponde ao número de prompts passados para o modelo.
  • initial_audio_sampling_rate (int, opcional) — Taxa de amostragem das initial_audio_waveforms, caso sejam fornecidas. Deve ser a mesma do modelo.
  • prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-computadas do modelo codificador de texto. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão calculadas a partir do argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto negativas pré-computadas do modelo de codificador de texto. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será calculado a partir do argumento de entrada negative_prompt.
  • attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos prompt_embeds. Se não for fornecida, a máscara de atenção será calculada a partir do argumento de entrada prompt.
  • negative_attention_mask (torch.LongTensor, opcional) — Máscara de atenção pré-computada a ser aplicada aos negative_text_audio_duration_embeds.
  • return_dict (bool, opcional, padrão True) — Se deve ou não retornar um StableDiffusionPipelineOutput em vez de uma tupla simples.
  • callback (Callable, opcional) — Uma função que é chamada a cada callback_steps passos durante a inferência. A função é chamada com os seguintes argumentos: callback(step: int, timestep: int, latents: torch.Tensor).
  • callback_steps (int, opcional, padrão 1) — A frequência com que a função callback é chamada. Se não for especificada, o callback é chamado a cada etapa.
  • output_type (str, opcional, padrão "pt") — O formato de saída do áudio gerado. Escolha entre "np" para retornar um np.ndarray do NumPy ou "pt" para retornar um objeto torch.Tensor do PyTorch. Defina como "latent" para retornar a saída do modelo de difusão latente (LDM).

Retorna

StableDiffusionPipelineOutput ou tuple

Se return_dict for True, StableDiffusionPipelineOutput é retornado, caso contrário, uma tuple é retornada, onde o primeiro elemento é uma lista com o áudio gerado.

A função de chamada do pipeline para geração.

Exemplos:

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

←LongCat-AudioDiT Stable Audio 3→