# AudioLDM 2 AudioLDM 2 diusulkan dalam [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734) oleh Haohe Liu dkk. AudioLDM 2 menerima prompt teks sebagai input dan memprediksi audio yang sesuai. Model ini dapat menghasilkan efek suara, ucapan manusia, dan musik yang dikondisikan oleh teks. Terinspirasi oleh [Stable Diffusion](./stable_diffusion/overview), AudioLDM 2 adalah model _latent diffusion model (LDM)_ teks-ke-audio yang mempelajari representasi audio kontinu dari embedding teks. Dua model pengkode teks digunakan untuk menghitung embedding teks dari input prompt: cabang teks dari [CLAP](https://huggingface.co/docs/transformers/main/en/model_doc/clap) dan pengkode dari [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5). Embedding teks ini kemudian diproyeksikan ke ruang embedding bersama oleh [AudioLDM2ProjectionModel](./audioldm2#diffusers.AudioLDM2ProjectionModel). Model [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2) _language model (LM)_ digunakan untuk memprediksi delapan vektor embedding baru secara auto-regresif, bersyarat pada embedding CLAP dan Flan-T5 yang telah diproyeksikan. Vektor embedding yang dihasilkan dan embedding teks Flan-T5 digunakan sebagai kondisioning cross-attention dalam LDM. [UNet](./audioldm2#diffusers.AudioLDM2UNet2DConditionModel) dari AudioLDM 2 unik dalam arti bahwa ia menerima **dua** embedding cross-attention, bukan satu kondisioning cross-attention, seperti pada sebagian besar LDM lainnya. Abstrak dari makalah tersebut adalah sebagai berikut: *Walaupun generasi audio memiliki kesamaan di antara berbagai jenis audio, seperti ucapan, musik, dan efek suara, merancang model untuk masing-masing jenis memerlukan pertimbangan yang cermat terhadap tujuan dan bias spesifik yang dapat sangat berbeda dari jenis lainnya. Untuk membawa kita lebih dekat ke perspektif terpadu dari generasi audio, makalah ini mengusulkan sebuah kerangka kerja yang memanfaatkan metode pembelajaran yang sama untuk generasi ucapan, musik, dan efek suara. Kerangka kerja kami memperkenalkan representasi umum audio, yang disebut "bahasa audio" (LOA). Setiap audio dapat diterjemahkan ke dalam LOA berdasarkan AudioMAE, sebuah model pembelajaran representasi pra-latih yang diawasi sendiri. Dalam proses generasi, kami menerjemahkan modalitas apa pun ke dalam LOA dengan menggunakan model GPT-2, dan kami melakukan pembelajaran generasi audio yang diawasi sendiri dengan model difusi laten yang dikondisikan pada LOA. Kerangka kerja yang diusulkan secara alami membawa keuntungan seperti kemampuan pembelajaran dalam konteks dan model AudioMAE serta model difusi laten pra-latih yang diawasi sendiri dan dapat digunakan kembali. Eksperimen pada benchmark utama untuk teks-ke-audio, teks-ke-musik, dan teks-ke-ucapan menunjukkan kinerja state-of-the-art atau kompetitif dibandingkan pendekatan sebelumnya. Kode, model pra-latih, dan demo kami tersedia di [URL https ini](https://audioldm.github.io/audioldm2).* Pipeline ini disumbangkan oleh [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) dan [Nguyễn Công Tú Anh](https://github.com/tuanh123789). Basis kode aslinya dapat ditemukan di [haoheliu/audioldm2](https://github.com/haoheliu/audioldm2). ## Tips ### Memilih checkpoint AudioLDM2 hadir dalam tiga varian. Dua checkpoint ini dapat diterapkan untuk tugas umum generasi teks-ke-audio. Checkpoint ketiga dilatih secara eksklusif untuk generasi teks-ke-musik. Semua checkpoint memiliki ukuran model yang sama untuk text encoder dan VAE. Perbedaan terletak pada ukuran dan kedalaman UNet. Lihat tabel di bawah untuk detail ketiga checkpoint: | Checkpoint | Tugas | Ukuran Model UNet | Ukuran Total Model | Data Pelatihan / h | |-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------| | [audioldm2](https://huggingface.co/cvssp/audioldm2) | Teks-ke-audio | 350M | 1.1B | 1150k | | [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | Teks-ke-audio | 750M | 1.5B | 1150k | | [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | Teks-ke-musik | 350M | 1.1B | 665k | | [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | Teks-ke-suara | 350M | 1.1B |10k | | [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | Teks-ke-suara | 350M | 1.1B | | ### Membangun prompt * Input prompt deskriptif paling efektif: gunakan kata sifat untuk menggambarkan suara (misalnya "high quality" atau "clear") dan buat prompt spesifik dalam konteksnya (misalnya "water stream in a forest" alih-alih "stream"). * Sebaiknya gunakan istilah umum seperti "cat" atau "dog" alih-alih nama spesifik atau objek abstrak yang mungkin tidak dikenal oleh model. * Menggunakan **negative prompt** dapat secara signifikan meningkatkan kualitas waveform yang dihasilkan, dengan mengarahkan proses generasi menjauh dari istilah-istilah yang berkorespondensi dengan audio berkualitas buruk. Coba gunakan negative prompt "Low quality." ### Mengontrol inferensi * _Kualitas_ sampel audio yang diprediksi dapat dikontrol melalui argumen `num_inference_steps`; jumlah langkah yang lebih tinggi menghasilkan audio dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. * _Panjang_ sampel audio yang diprediksi dapat dikendalikan dengan memvariasikan argumen `audio_length_in_s`. ### Mengevaluasi waveform yang dihasilkan: * Kualitas waveform yang dihasilkan dapat bervariasi secara signifikan berdasarkan seed. Coba menghasilkan dengan seed yang berbeda hingga Anda menemukan hasil yang memuaskan. * Beberapa waveform dapat dihasilkan sekaligus: atur `num_waveforms_per_prompt` ke nilai yang lebih besar dari 1. Penilaian otomatis akan dilakukan antara waveform yang dihasilkan dan teks prompt, dan audio akan diurutkan dari yang terbaik hingga terburuk sesuai dengan hasilnya. Contoh berikut menunjukkan cara membangun generasi musik dan ucapan yang baik menggunakan tips yang disebutkan di atas: [contoh](./audioldm2#diffusers.AudioLDM2Pipeline.__call__.example). > [!TIP] > Pastikan untuk melihat [panduan](../../using-diffusers/schedulers) Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian [reuse components across pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline. ## AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] #### diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]] ```python diffusers.AudioLDM2Pipeline(vae: AutoencoderKL, text_encoder: ClapModel, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | transformers.models.vits.modeling_vits.VitsModel, projection_model: AudioLDM2ProjectionModel, language_model: GPT2LMHeadModel, tokenizer: RobertaTokenizer, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.vits.tokenization_vits.VitsTokenizer, feature_extractor: ClapFeatureExtractor, unet: AudioLDM2UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vocoder: SpeechT5HifiGan) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150) **Parameter:** vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. text_encoder ([ClapModel](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapModel)) : Text-encoder beku pertama. AudioLDM2 menggunakan model embedding audio-teks gabungan [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), khususnya varian [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused). Cabang teks digunakan untuk mengkodekan prompt teks menjadi embedding prompt. Model audio-teks lengkap digunakan untuk merangking waveform yang dihasilkan terhadap prompt teks dengan menghitung skor kemiripan. text_encoder_2 ([`~transformers.T5EncoderModel`, `~transformers.VitsModel`]) : Text-encoder beku kedua. AudioLDM2 menggunakan encoder dari [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/flan-t5-large](https://huggingface.co/google/flan-t5-large). Text-encoder beku kedua digunakan untuk TTS. AudioLDM2 menggunakan encoder dari [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel). projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/id/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : Model terlatih yang digunakan untuk memproyeksikan secara linear hidden-states dari model text encoder pertama dan kedua serta menyisipkan embedding token SOS dan EOS yang dipelajari. Hidden-states yang diproyeksikan dari kedua text encoder tersebut digabungkan (concatenated) untuk memberikan input ke language model. Learned Position Embedding untuk hidden-states Vits language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.GPT2Model)) : Model bahasa auto-regresif yang digunakan untuk menghasilkan urutan hidden-states yang dikondisikan pada output proyeksi dari dua encoder teks. tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : Tokenizer untuk mem-tokenisasi teks untuk text-encoder beku pertama. tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : Tokenizer untuk mem-tokenisasi teks untuk text-encoder beku kedua. feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : Ekstraktor fitur untuk memproses prapengolahan gelombang audio yang dihasilkan menjadi spektrogram log-mel untuk penilaian otomatis. unet ([UNet2DConditionModel](/docs/diffusers/main/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Sebuah `UNet2DConditionModel` untuk menghilangkan noise dari latens audio yang telah dienkod. scheduler ([SchedulerMixin](/docs/diffusers/main/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Scheduler yang digunakan bersama dengan `unet` untuk menghilangkan noise pada latens audio yang telah dienkod. Bisa berupa salah satu dari [DDIMScheduler](/docs/diffusers/main/id/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), atau [PNDMScheduler](/docs/diffusers/main/id/api/schedulers/pndm#diffusers.PNDMScheduler). vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/main/en/model_doc/speecht5#transformers.SpeechT5HifiGan)) : Vocoder dari kelas `SpeechT5HifiGan` untuk mengonversi latens mel-spectrogram menjadi waveform audio akhir. Pipeline untuk generasi teks-ke-audio menggunakan AudioLDM2. Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/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.AudioLDM2Pipeline.__call__]] ```python __call__(prompt: str | list[str] = None, transcription: str | list[str] = None, audio_length_in_s: float | None = None, num_inference_steps: int = 200, guidance_scale: float = 3.5, 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, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None, return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int | None = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, output_type: str | None = 'np') ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L844) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk memandu generasi audio. Jika tidak didefinisikan, Anda perlu meneruskan `prompt_embeds`. transcription (`str` atau `list[str]`, *opsional*) -- Transkrip untuk teks ke suara. audio_length_in_s (`int`, *opsional*, default 10.24) : Panjang sampel audio yang dihasilkan dalam detik. num_inference_steps (`int`, *opsional*, defaultnya 200) : 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 3.5) : 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. Jika `num_waveforms_per_prompt > 1`, maka penilaian otomatis dilakukan antara output yang dihasilkan dan teks prompt. Penilaian ini merangking waveform yang dihasilkan berdasarkan kemiripan kosinusnya dengan input teks dalam ruang embedding teks-audio gabungan. 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/main/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 spektrogram. 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. prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (pemberian bobot pada prompt). Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (pemberian bobot pada prompt). Jika tidak disediakan, `negative_prompt_embeds` akan dibuat dari argumen input `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya dari model bahasa GPT2. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya dari model bahasa GPT2. 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*) : Attention mask yang sudah dihitung sebelumnya untuk diterapkan pada `negative_prompt_embeds`. Jika tidak disediakan, attention mask akan dihitung dari argumen input `negative_prompt`. max_new_tokens (`int`, *opsional*, defaultnya None) : Jumlah token baru yang akan dihasilkan dengan model bahasa GPT2. Jika tidak diberikan, jumlah token akan diambil dari konfigurasi model. return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [StableDiffusionPipelineOutput](/docs/diffusers/main/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. cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan dalam [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). output_type (`str`, *opsional*, defaultnya `"np"`) : 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/main/id/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) atau `tuple` Jika `return_dict` adalah `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/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 >>> 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[[diffusers.AudioLDM2Pipeline.enable_model_cpu_offload]] ```python enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = 'cuda') ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226) Me-offload semua model ke CPU menggunakan accelerate, mengurangi penggunaan memori dengan dampak kecil pada kinerja. Dibandingkan dengan `enable_sequential_cpu_offload`, metode ini memindahkan satu model utuh ke GPU pada saat metode `forward` model tersebut dipanggil, dan model tetap berada di GPU hingga model berikutnya dijalankan. Penghematan memori lebih rendah dibandingkan dengan `enable_sequential_cpu_offload`, tetapi kinerjanya jauh lebih baik karena eksekusi iteratif dari `unet`. #### encode_prompt[[diffusers.AudioLDM2Pipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_waveforms_per_prompt, do_classifier_free_guidance, transcription = None, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, generated_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_generated_prompt_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, negative_attention_mask: typing.Optional[torch.LongTensor] = None, max_new_tokens: int | None = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L331) **Parameter:** prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod transcription (`str` atau `list[str]`) : transkripsi teks ke suara device (`torch.device`) : perangkat torch num_waveforms_per_prompt (`int`) : jumlah waveform yang harus dihasilkan per prompt do_classifier_free_guidance (`bool`) : apakah akan menggunakan classifier free guidance atau tidak negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi audio. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dihitung sebelumnya dari model Flan T5. 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 Flan T5. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, negative_prompt_embeds akan dihitung dari argumen input `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya dari model bahasa GPT2. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya dari model bahasa GPT2. 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*) : Attention mask yang sudah dihitung sebelumnya untuk diterapkan pada `negative_prompt_embeds`. Jika tidak disediakan, attention mask akan dihitung dari argumen input `negative_prompt`. max_new_tokens (`int`, *opsional*, defaultnya None) : Jumlah token baru yang akan dihasilkan dengan model bahasa GPT2. **Mengembalikan:** prompt_embeds (`torch.Tensor`) Text embeddings dari model Flan T5. attention_mask (`torch.LongTensor`): Attention mask yang akan diterapkan pada `prompt_embeds`. generated_prompt_embeds (`torch.Tensor`): Text embeddings yang dihasilkan dari model bahasa GPT2. Mengkodekan prompt menjadi hidden states dari text encoder. Contoh: ```python >>> 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[[diffusers.AudioLDM2Pipeline.generate_language_model]] ```python generate_language_model(inputs_embeds: Tensor = None, max_new_tokens: int = 8, **model_kwargs) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L278) **Parameter:** inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) : Urutan yang digunakan sebagai prompt untuk generasi. max_new_tokens (`int`) : Jumlah token baru yang akan dihasilkan. model_kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. **Mengembalikan:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`) Urutan hidden-states yang dihasilkan. Membuat urutan hidden-states dari model bahasa, dikondisikan pada input embedding. ## AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]] #### diffusers.AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]] ```python diffusers.AudioLDM2ProjectionModel(text_encoder_dim, text_encoder_1_dim, langauge_model_dim, use_learned_position_embedding = None, max_seq_length = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60) **Parameter:** text_encoder_dim (`int`) : Dimensi dari text embeddings yang berasal dari text encoder pertama (CLAP). text_encoder_1_dim (`int`) : Dimensi dari teks embedding dari pengkode teks kedua (T5 atau VITS). langauge_model_dim (`int`) : Dimensi dari teks embeddings dari model bahasa (GPT2). Model proyeksi linear sederhana untuk memetakan dua embedding teks ke ruang laten bersama. Model ini juga menyisipkan vektor embedding yang dipelajari di awal dan akhir dari masing-masing urutan embedding teks. Setiap variabel yang ditambahkan dengan `_1` merujuk pada yang sesuai dengan encoder teks kedua. Selain itu, variabel berasal dari encoder pertama. #### forward[[diffusers.AudioLDM2ProjectionModel.forward]] ```python forward(hidden_states: typing.Optional[torch.Tensor] = None, hidden_states_1: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, attention_mask_1: typing.Optional[torch.LongTensor] = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L104) **Parameter:** hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, text_encoder_dim)`, *opsional*) : Embedding teks dari text encoder pertama (CLAP). hidden_states_1 (`torch.Tensor` dengan bentuk `(batch_size, sequence_length_1, text_encoder_1_dim)`, *opsional*) : Embedding teks dari text encoder kedua (T5 atau VITS). attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Attention mask untuk `hidden_states`. attention_mask_1 (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length_1)`, *opsional*) : Mask perhatian untuk `hidden_states_1`. **Mengembalikan:** `AudioLDM2ProjectionModelOutput` Embedding teks yang diproyeksikan dari kedua encoder teks, yang digabungkan sepanjang dimensi sekuens, beserta mask perhatian gabungan mereka. ## AudioLDM2UNet2DConditionModel[[diffusers.AudioLDM2UNet2DConditionModel]] #### diffusers.AudioLDM2UNet2DConditionModel[[diffusers.AudioLDM2UNet2DConditionModel]] ```python diffusers.AudioLDM2UNet2DConditionModel(sample_size: int | None = None, in_channels: int = 4, out_channels: int = 4, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple[str] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int] = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] = 1, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, class_embeddings_concat: bool = False) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45) **Parameter:** sample_size (`int` atau `tuple[int, int]`, *opsional*, defaultnya `None`) : Tinggi dan lebar sampel input/output. in_channels (`int`, *opsional*, defaultnya 4) : Jumlah channel dalam sampel input. out_channels (`int`, *opsional*, defaultnya 4) : Jumlah channel pada output. flip_sin_to_cos (`bool`, *opsional*, defaultnya `False`) : Apakah akan membalik sin menjadi cos dalam time embedding. freq_shift (`int`, *opsional*, default 0) : Pergeseran frekuensi yang diterapkan pada time embedding. down_block_types (`tuple[str]`, *opsional*, defaultnya `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Tuple dari blok downsample yang akan digunakan. mid_block_type (`str`, *opsional*, defaultnya `"UNetMidBlock2DCrossAttn"`) : Jenis blok untuk bagian tengah UNet, hanya bisa berupa `UNetMidBlock2DCrossAttn` untuk AudioLDM2. up_block_types (`tuple[str]`, *opsional*, defaultnya `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Tuple dari blok upsample yang akan digunakan. only_cross_attention (`bool` atau `tuple[bool]`, *opsional*, default ke `False`) : Apakah akan menyertakan self-attention dalam blok transformer dasar, lihat `BasicTransformerBlock`. block_out_channels (`tuple[int]`, *opsional*, defaultnya `(320, 640, 1280, 1280)`) : Tuple dari output channels untuk setiap block. layers_per_block (`int`, *opsional*, defaultnya 2) : Jumlah lapisan per blok. downsample_padding (`int`, *opsional*, default 1) : Padding yang digunakan untuk konvolusi downsampling. mid_block_scale_factor (`float`, *opsional*, default 1.0) : Faktor skala yang digunakan untuk blok tengah. act_fn (`str`, *opsional*, defaultnya `"silu"`) : Fungsi aktivasi yang akan digunakan. norm_num_groups (`int`, *opsional*, default 32) : Jumlah grup yang digunakan untuk normalisasi. Jika `None`, lapisan normalisasi dan aktivasi dilewati dalam pascapemrosesan. norm_eps (`float`, *opsional*, default 1e-5) : Epsilon yang digunakan untuk normalisasi. cross_attention_dim (`int` atau `tuple[int]`, *opsional*, default 1280) : Dimensi dari fitur cross attention. transformer_layers_per_block (`int` atau `tuple[int]`, *opsional*, default 1) : Jumlah blok transformer bertipe `BasicTransformerBlock`. Hanya relevan untuk `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`. attention_head_dim (`int`, *opsional*, defaultnya 8) : Dimensi dari kepala perhatian (attention heads). num_attention_heads (`int`, *opsional*) : Jumlah kepala perhatian. Jika tidak didefinisikan, secara default menggunakan `attention_head_dim` resnet_time_scale_shift (`str`, *opsional*, defaultnya `"default"`) : Konfigurasi pergeseran skala waktu untuk blok ResNet (lihat `ResnetBlock2D`). Pilih dari `default` atau `scale_shift`. class_embed_type (`str`, *opsional*, defaultnya `None`) : Jenis class embedding yang akan digunakan, yang pada akhirnya dijumlahkan dengan time embeddings. Pilih dari `None`, `"timestep"`, `"identity"`, `"projection"`, atau `"simple_projection"`. num_class_embeds (`int`, *opsional*, defaultnya `None`) : Dimensi input dari matriks embedding yang dapat dipelajari untuk diproyeksikan ke `time_embed_dim`, saat melakukan kondisioning kelas dengan `class_embed_type` yang sama dengan `None`. time_embedding_type (`str`, *opsional*, defaultnya `positional`) : Jenis position embedding yang digunakan untuk timesteps. Pilih dari `positional` atau `fourier`. time_embedding_dim (`int`, *opsional*, defaultnya `None`) : Penggantian opsional untuk dimensi dari time embedding yang diproyeksikan. time_embedding_act_fn (`str`, *opsional*, defaultnya `None`) : Fungsi aktivasi opsional yang hanya digunakan sekali pada time embeddings sebelum diteruskan ke bagian lain dari UNet. Pilih dari `silu`, `mish`, `gelu`, dan `swish`. timestep_post_act (`str`, *opsional*, defaultnya `None`) : Fungsi aktivasi kedua yang digunakan dalam penanaman timestep. Pilih dari `silu`, `mish` dan `gelu`. time_cond_proj_dim (`int`, *opsional*, defaultnya `None`) : Dimensi dari lapisan `cond_proj` dalam embedding timestep. conv_in_kernel (`int`, *opsional*, default ke `3`) : Ukuran kernel dari layer `conv_in`. conv_out_kernel (`int`, *opsional*, default ke `3`) : Ukuran kernel dari lapisan `conv_out`. projection_class_embeddings_input_dim (`int`, *opsional*) : Dimensi dari input `class_labels` ketika `class_embed_type="projection"`. Wajib diisi ketika `class_embed_type="projection"`. class_embeddings_concat (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggabungkan time embeddings dengan class embeddings. Model 2D UNet bersyarat yang menerima sampel berisik, kondisi, dan timestep, lalu mengembalikan output berbentuk sampel. Dibandingkan dengan [UNet2DConditionModel](/docs/diffusers/main/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel) standar, varian ini secara opsional menyertakan lapisan self-attention tambahan di setiap blok Transformer, serta beberapa lapisan cross-attention. Model ini juga memungkinkan hingga dua embedding cross-attention, yaitu `encoder_hidden_states` dan `encoder_hidden_states_1`. Model ini mewarisi dari [ModelMixin](/docs/diffusers/main/id/api/models/overview#diffusers.ModelMixin). Periksa dokumentasi kelas induk untuk metode generiknya yang diimplementasikan untuk semua model (seperti mengunduh atau menyimpan). #### forward[[diffusers.AudioLDM2UNet2DConditionModel.forward]] ```python forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True, encoder_hidden_states_1: typing.Optional[torch.Tensor] = None, encoder_attention_mask_1: typing.Optional[torch.Tensor] = None) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494) **Parameter:** sample (`torch.Tensor`) : Tensor input berisik dengan bentuk berikut `(batch, channel, height, width)`. timestep (`torch.Tensor` atau `float` atau `int`) : Jumlah timestep untuk mendenoise input. encoder_hidden_states (`torch.Tensor`) : Hidden states encoder dengan bentuk `(batch, sequence_length, feature_dim)`. encoder_attention_mask (`torch.Tensor`) : Mask cross-attention dengan bentuk `(batch, sequence_length)` diterapkan pada `encoder_hidden_states`. Jika `True`, mask dipertahankan; jika `False`, mask dibuang. Mask akan dikonversi menjadi bias, yang menambahkan nilai negatif besar ke skor attention yang sesuai dengan token "discard". return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [UNet2DConditionOutput](/docs/diffusers/main/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) alih-alih tuple biasa. cross_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttnProcessor`. encoder_hidden_states_1 (`torch.Tensor`, *opsional*) : Sekumpulan hidden states encoder kedua dengan bentuk `(batch, sequence_length_2, feature_dim_2)`. Dapat digunakan untuk mengondisikan model pada kumpulan embeddings yang berbeda dari `encoder_hidden_states`. encoder_attention_mask_1 (`torch.Tensor`, *opsional*) : Mask cross-attention dengan bentuk `(batch, sequence_length_2)` diterapkan pada `encoder_hidden_states_1`. Jika `True`, mask dipertahankan; jika `False`, mask dibuang. Mask akan dikonversi menjadi bias, yang menambahkan nilai negatif besar ke skor perhatian yang sesuai dengan token "discard". **Mengembalikan:** [UNet2DConditionOutput](/docs/diffusers/main/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) atau `tuple` Jika `return_dict` bernilai True, sebuah [UNet2DConditionOutput](/docs/diffusers/main/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) akan dikembalikan, selain itu sebuah `tuple` akan dikembalikan di mana elemen pertama adalah tensor sampel. Metode forward dari [AudioLDM2UNet2DConditionModel](/docs/diffusers/main/id/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel). ## AudioPipelineOutput[[diffusers.AudioPipelineOutput]] #### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]] ```python diffusers.AudioPipelineOutput(audios: ndarray) ``` [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L149) **Parameter:** audios (`np.ndarray`) : Daftar sampel audio yang telah didenois dari array NumPy dengan bentuk `(batch_size, num_channels, sample_rate)`. Kelas output untuk pipeline audio.