# Stable Audio

Stable Audio foi proposto em [Stable Audio Open](https://huggingface.co/papers/2407.14358) 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](https://huggingface.co/ylacombe). A base de código original pode ser encontrada em [Stability-AI/stable-audio-tools](https://github.com/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](../../quantization/overview) 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](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_audio#diffusers.StableAudioPipeline) quantizado para inferência com bitsandbytes.

```py
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[[diffusers.StableAudioPipeline]]

#### diffusers.StableAudioPipeline[[diffusers.StableAudioPipeline]]

```python
diffusers.StableAudioPipeline(vae: AutoencoderOobleck, text_encoder: T5EncoderModel, projection_model: StableAudioProjectionModel, tokenizer: T5Tokenizer, transformer: StableAudioDiTModel, scheduler: EDMDPMSolverMultistepScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py#L78)

**Parâmetros:**

vae ([AutoencoderOobleck](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_oobleck#diffusers.AutoencoderOobleck)) : Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder ([T5EncoderModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5EncoderModel)) : Codificador de texto congelado. O StableAudio usa o codificador do [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google-t5/t5-base](https://huggingface.co/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 ao modelo transformer.

tokenizer ([T5Tokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5Tokenizer)) : Tokenizador para tokenizar o texto para o codificador de texto congelado.

transformer ([StableAudioDiTModel](/docs/diffusers/v0.43.0/pt/api/models/stable_audio_transformer#diffusers.StableAudioDiTModel)) : Um `StableAudioDiTModel` para desruidar os latentes de áudio codificados.

scheduler ([EDMDPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/edm_multistep_dpm_solver#diffusers.EDMDPMSolverMultistepScheduler)) : Um agendador 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](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.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__[[diffusers.StableAudioPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, audio_end_in_s: float | None = None, audio_start_in_s: float | None = 0.0, num_inference_steps: int = 100, guidance_scale: float = 7.0, 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, initial_audio_waveforms: typing.Optional[torch.Tensor] = None, initial_audio_sampling_rate: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int | None = 1, output_type: str | None = 'pt')
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py#L462)

**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 final 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 remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em um áudio de maior qualidade, às custas 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 fortemente ligado ao `prompt` de texto, 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, você precisa 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](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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*) : Embutidos de texto pré-computados do modelo codificador de texto. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os embutidos de texto serão computados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embebidings de texto negativos pré-computados 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](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) em vez de uma tupla simples.

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas 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](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com o áudio gerado.

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

Exemplos:
```py
>>> 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)
```