# Stable Audio

Stable Audio diusulkan dalam [Stable Audio Open](https://huggingface.co/papers/2407.14358) oleh Zach Evans dkk. Model ini menerima prompt teks sebagai input dan memprediksi sampel suara atau musik yang sesuai.

Stable Audio Open menghasilkan audio stereo dengan panjang variabel (hingga 47 detik) pada 44,1kHz dari prompt teks. Model ini terdiri dari tiga komponen: autoencoder yang mengompres waveform menjadi panjang urutan yang dapat dikelola, embedding teks berbasis T5 untuk kondisioning teks, dan model difusi berbasis transformer (DiT) yang beroperasi di ruang laten autoencoder.

Stable Audio dilatih pada korpus sekitar 48k rekaman audio, di mana sekitar 47k berasal dari Freesound dan sisanya dari Free Music Archive (FMA). Semua file audio berlisensi CC0, CC BY, atau CC Sampling+. Data ini digunakan untuk melatih autoencoder dan DiT.

Abstrak dari makalah tersebut adalah sebagai berikut: *Model generatif terbuka sangat penting bagi komunitas, karena memungkinkan fine-tuning dan berfungsi sebagai baseline saat mempresentasikan model baru. Namun, sebagian besar model text-to-audio saat ini bersifat privat dan tidak dapat diakses oleh seniman maupun peneliti untuk dikembangkan lebih lanjut. Di sini, kami menjelaskan arsitektur dan proses pelatihan dari model text-to-audio open-weights baru yang dilatih dengan data Creative Commons. Evaluasi kami menunjukkan bahwa kinerja model ini kompetitif dengan state-of-the-art di berbagai metrik. Secara khusus, hasil FDopenl3 yang dilaporkan (mengukur realisme dari generasi) menunjukkan potensinya untuk sintesis suara stereo berkualitas tinggi pada 44.1kHz.*

Pipeline ini disumbangkan oleh [Yoach Lacombe](https://huggingface.co/ylacombe). Basis kode aslinya dapat ditemukan di [Stability-AI/stable-audio-tools](https://github.com/Stability-AI/stable-audio-tools).

## Tips

Saat menyusun prompt, perhatikan hal-hal berikut:

* Input prompt deskriptif paling efektif; gunakan kata sifat untuk menggambarkan suara (misalnya, "high quality" atau "clear") dan buat prompt spesifik sesuai konteks jika memungkinkan (misalnya, "melodic techno with a fast beat and synths" lebih baik daripada "techno").
* Menggunakan *negative prompt* dapat secara signifikan meningkatkan kualitas audio yang dihasilkan. Coba gunakan negative prompt "low quality, average quality".

Selama inferensi:

* _Kualitas_ sampel audio yang dihasilkan dapat dikontrol melalui argumen `num_inference_steps`; langkah yang lebih tinggi menghasilkan audio dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
* Beberapa waveform dapat dihasilkan sekaligus: atur `num_waveforms_per_prompt` ke nilai lebih dari 1 untuk mengaktifkannya. Penilaian otomatis akan dilakukan antara waveform yang dihasilkan dan teks prompt, dan audio akan diurutkan dari yang terbaik hingga terburuk sesuai dengan hasilnya.

## Kuantisasi

Quantization membantu mengurangi kebutuhan memori untuk model yang sangat besar dengan menyimpan bobot model dalam tipe data presisi yang lebih rendah. Namun, quantization dapat memiliki dampak yang bervariasi terhadap kualitas video tergantung pada model video yang digunakan.

Lihat ringkasan [Kuantisasi](../../quantization/overview) untuk mempelajari lebih lanjut tentang backend kuantisasi yang didukung dan memilih backend kuantisasi yang mendukung kasus penggunaan Anda. Contoh di bawah ini menunjukkan cara memuat [StableAudioPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/stable_audio#diffusers.StableAudioPipeline) yang dikuantisasi untuk inferensi dengan 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)
```

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

**Parameter:**

vae ([AutoencoderOobleck](/docs/diffusers/v0.43.0/id/api/models/autoencoder_oobleck#diffusers.AutoencoderOobleck)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.

text_encoder ([T5EncoderModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5EncoderModel)) : Pengkode teks beku. StableAudio menggunakan pengkode dari [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google-t5/t5-base](https://huggingface.co/google-t5/t5-base).

projection_model (`StableAudioProjectionModel`) : Model terlatih yang digunakan untuk memproyeksikan secara linear hidden-states dari model text encoder serta detik awal dan akhir. Hidden-states yang diproyeksikan dari encoder dan detik kondisional digabungkan (concatenated) untuk memberikan input ke model transformer.

tokenizer ([T5Tokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5Tokenizer)) : Tokenizer untuk mem-tokenisasi teks bagi text-encoder yang dibekukan.

transformer ([StableAudioDiTModel](/docs/diffusers/v0.43.0/id/api/models/stable_audio_transformer#diffusers.StableAudioDiTModel)) : Sebuah `StableAudioDiTModel` untuk menghilangkan noise dari latens audio yang telah dikodekan.

scheduler ([EDMDPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/edm_multistep_dpm_solver#diffusers.EDMDPMSolverMultistepScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens audio yang telah dikodekan.

Pipeline untuk generasi teks-ke-audio menggunakan StableAudio.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

#### __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')
```

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

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk memandu generasi audio. Jika tidak didefinisikan, Anda perlu meneruskan `prompt_embeds`.

audio_end_in_s (`float`, *opsional*, default 47.55) : Indeks akhir audio dalam detik.

audio_start_in_s (`float`, *opsional*, default 0) : Indeks awal audio dalam detik.

num_inference_steps (`int`, *opsional*, default 100) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan audio dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

guidance_scale (`float`, *opsional*, default 7.0) : Nilai guidance scale yang lebih tinggi mendorong model untuk menghasilkan audio yang sangat terkait dengan `prompt` teks, dengan mengorbankan kualitas suara yang lebih rendah. Guidance scale diaktifkan ketika `guidance_scale > 1`.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan apa yang tidak boleh disertakan dalam generasi audio. Jika tidak didefinisikan, Anda perlu meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (`guidance_scale < 1`).

num_waveforms_per_prompt (`int`, *opsional*, default 1) : Jumlah waveform yang akan dihasilkan per prompt.

eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dari paper [DDIM](https://huggingface.co/papers/2010.02502). Hanya berlaku untuk [DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), dan diabaikan pada scheduler lainnya.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Sebuah [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi audio. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.

initial_audio_waveforms (`torch.Tensor`, *opsional*) : Gelombang audio awal opsional yang akan digunakan sebagai gelombang audio awal untuk generasi. Harus memiliki bentuk `(batch_size, num_channels, audio_length)` atau `(batch_size, audio_length)`, di mana `batch_size` sesuai dengan jumlah prompt yang diteruskan ke model.

initial_audio_sampling_rate (`int`, *opsional*) : Laju sampling dari `initial_audio_waveforms`, jika disediakan. Harus sama dengan model.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dihitung sebelumnya dari model text encoder. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, embedding teks akan dihitung dari argumen input `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dihitung sebelumnya dari model pengkode teks. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dihitung dari argumen input `negative_prompt`.

attention_mask (`torch.LongTensor`, *opsional*) : Attention mask yang sudah dihitung sebelumnya untuk diterapkan pada `prompt_embeds`. Jika tidak disediakan, attention mask akan dihitung dari argumen input `prompt`.

negative_attention_mask (`torch.LongTensor`, *opsional*) : Mask perhatian yang telah dihitung sebelumnya untuk diterapkan pada `negative_text_audio_duration_embeds`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) alih-alih tuple biasa.

callback (`Callable`, *opsional*) : Fungsi yang dipanggil setiap `callback_steps` langkah selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opsional*, default 1) : Frekuensi pemanggilan fungsi `callback`. Jika tidak ditentukan, callback dipanggil di setiap langkah.

output_type (`str`, *opsional*, defaultnya `"pt"`) : Format output dari audio yang dihasilkan. Pilih antara `"np"` untuk mengembalikan `np.ndarray` NumPy atau `"pt"` untuk mengembalikan objek `torch.Tensor` PyTorch. Atur ke `"latent"` untuk mengembalikan output model difusi laten (LDM).

**Mengembalikan:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) atau `tuple`

Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan audio yang dihasilkan.

Fungsi panggilan untuk pipeline pada generasi.

Contoh:
```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)
```