# AudioLDM 2 AudioLDM 2 được đề xuất trong [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734) của Haohe Liu và cộng sự. AudioLDM 2 nhận một prompt văn bản làm đầu vào và dự đoán âm thanh tương ứng. Nó có thể tạo ra hiệu ứng âm thanh, giọng nói con người và nhạc có điều kiện theo văn bản. Lấy cảm hứng từ [Stable Diffusion](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/overview), AudioLDM 2 là một _latent diffusion model (LDM)_ từ văn bản sang âm thanh, học các biểu diễn âm thanh liên tục từ các vector nhúng văn bản. Hai mô hình mã hóa văn bản được sử dụng để tính toán các vector nhúng văn bản từ đầu vào prompt: nhánh văn bản của [CLAP](https://huggingface.co/docs/transformers/main/en/model_doc/clap) và bộ mã hóa của [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5). Các vector nhúng văn bản này sau đó được chiếu vào một không gian nhúng chung bởi một [AudioLDM2ProjectionModel](https://huggingface.co/docs/diffusers/main/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel). Một _language model (LM)_ [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2) được sử dụng để dự đoán tự hồi quy tám vector nhúng mới, có điều kiện dựa trên các vector nhúng CLAP và Flan-T5 đã được chiếu. Các vector nhúng được tạo ra và các vector nhúng văn bản Flan-T5 được sử dụng làm điều kiện chú ý chéo (cross-attention conditioning) trong LDM. [UNet](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel) của AudioLDM 2 là độc đáo ở chỗ nó nhận **hai** vector nhúng chú ý chéo, thay vì một điều kiện chú ý chéo như trong hầu hết các LDM khác. Tóm tắt của bài báo như sau: *Mặc dù việc tạo âm thanh có những điểm chung giữa các loại âm thanh khác nhau, chẳng hạn như giọng nói, nhạc và hiệu ứng âm thanh, việc thiết kế mô hình cho từng loại đòi hỏi phải xem xét kỹ lưỡng các mục tiêu và thiên kiến cụ thể, vốn có thể khác biệt đáng kể so với các loại khác. Để tiến gần hơn đến một góc nhìn thống nhất về tạo âm thanh, bài báo này đề xuất một khung làm việc sử dụng cùng một phương pháp học cho việc tạo giọng nói, nhạc và hiệu ứng âm thanh. Khung làm việc của chúng tôi giới thiệu một biểu diễn chung của âm thanh, được gọi là "ngôn ngữ của âm thanh" (LOA). Bất kỳ âm thanh nào cũng có thể được dịch sang LOA dựa trên AudioMAE, một mô hình học biểu diễn tiền huấn luyện tự giám sát. Trong quá trình tạo, chúng tôi dịch bất kỳ chế độ nào sang LOA bằng cách sử dụng mô hình GPT-2, và thực hiện học tạo âm thanh tự giám sát bằng một mô hình khuếch tán tiềm ẩn có điều kiện dựa trên LOA. Khung làm việc được đề xuất mang lại các lợi thế tự nhiên như khả năng học trong ngữ cảnh và các mô hình AudioMAE và khuếch tán tiềm ẩn tiền huấn luyện tự giám sát có thể tái sử dụng. Các thí nghiệm trên các bộ chuẩn đánh giá chính về text-to-audio, text-to-music và text-to-speech cho thấy hiệu suất tiên tiến hoặc cạnh tranh so với các phương pháp trước đó. Mã nguồn, mô hình tiền huấn luyện và demo của chúng tôi có sẵn tại [this https URL](https://audioldm.github.io/audioldm2).* Pipeline này được đóng góp bởi [sanchit-gandhi](https://huggingface.co/sanchit-gandhi) và [Nguyễn Công Tú Anh](https://github.com/tuanh123789). Mã nguồn gốc có thể được tìm thấy tại [haoheliu/audioldm2](https://github.com/haoheliu/audioldm2). ## Mẹo ### Chọn checkpoint AudioLDM2 có ba biến thể. Hai checkpoint trong số này áp dụng cho tác vụ chung là tạo audio từ văn bản. Checkpoint thứ ba được huấn luyện riêng cho việc tạo nhạc từ văn bản. Tất cả các checkpoint chia sẻ cùng kích thước mô hình cho text encoder và VAE. Chúng khác nhau về kích thước và độ sâu của UNet. Xem bảng bên dưới để biết chi tiết về ba checkpoint: | Checkpoint | Nhiệm vụ | Kích thước Mô hình UNet | Tổng kích thước Mô hình | Dữ liệu huấn luyện / h | |-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------| | [audioldm2](https://huggingface.co/cvssp/audioldm2) | Văn bản thành âm thanh | 350M | 1.1B | 1150k | | [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | Văn bản thành âm thanh | 750M | 1.5B | 1150k | | [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | Văn bản thành nhạc | 350M | 1.1B | 665k | | [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | Chuyển văn bản thành giọng nói | 350M | 1.1B |10k | | [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | Chuyển văn bản thành giọng nói | 350M | 1.1B | | ### Xây dựng một prompt * Đầu vào prompt mô tả chi tiết hoạt động tốt nhất: hãy dùng tính từ để mô tả âm thanh (ví dụ "chất lượng cao" hoặc "rõ ràng") và làm cho prompt cụ thể về ngữ cảnh (ví dụ "dòng nước trong rừng" thay vì "dòng nước"). * Tốt nhất là nên sử dụng các thuật ngữ chung như "cat" hoặc "dog" thay vì các tên riêng hoặc các đối tượng trừu tượng mà mô hình có thể không quen thuộc. * Việc sử dụng **negative prompt** có thể cải thiện đáng kể chất lượng của waveform được tạo ra, bằng cách định hướng quá trình tạo ra xa khỏi các từ ngữ tương ứng với âm thanh chất lượng kém. Hãy thử sử dụng negative prompt là "Low quality." ### Kiểm soát suy luận * _Chất lượng_ của mẫu âm thanh dự đoán có thể được điều chỉnh bằng tham số `num_inference_steps`; số bước càng cao thì chất lượng âm thanh càng tốt, nhưng suy luận sẽ chậm hơn. * _Độ dài_ của mẫu âm thanh dự đoán có thể được điều chỉnh bằng cách thay đổi đối số `audio_length_in_s`. ### Đánh giá các dạng sóng đã tạo: * Chất lượng của các waveform được tạo ra có thể thay đổi đáng kể tùy thuộc vào seed. Hãy thử tạo với các seed khác nhau cho đến khi bạn tìm được một kết quả tạo ra thỏa mãn. * Có thể tạo nhiều dạng sóng cùng lúc: đặt `num_waveforms_per_prompt` thành một giá trị lớn hơn 1. Việc chấm điểm tự động sẽ được thực hiện giữa các dạng sóng được tạo và văn bản prompt, và các tệp âm thanh sẽ được xếp hạng từ tốt nhất đến kém nhất tương ứng. Ví dụ sau minh họa cách tạo ra nhạc và giọng nói chất lượng tốt bằng cách áp dụng các mẹo đã nêu ở trên: [ví dụ](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2Pipeline.__call__.example). > [!TIP] > Hãy chắc chắn xem qua [hướng dẫn](../../using-diffusers/schedulers) về Schedulers để tìm hiểu cách khám phá sự đánh đổi giữa tốc độ và chất lượng của scheduler, và xem phần [tái sử dụng các thành phần giữa các pipeline](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) để tìm hiểu cách nạp các thành phần giống nhau vào nhiều pipeline một cách hiệu quả. ## 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150) **Tham số:** vae ([AutoencoderKL](/docs/diffusers/v0.43.0/vi/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Mô hình Variational Auto-Encoder (VAE) để mã hóa và giải mã hình ảnh sang và từ các biểu diễn ẩn. text_encoder ([ClapModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clap#transformers.ClapModel)) : Bộ mã hóa văn bản đóng băng đầu tiên. AudioLDM2 sử dụng mô hình nhúng âm thanh-văn bản kết hợp [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), cụ thể là biến thể [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused). Nhánh văn bản được dùng để mã hóa prompt văn bản thành nhúng prompt. Mô hình âm thanh-văn bản đầy đủ được dùng để xếp hạng các dạng sóng được tạo ra so với prompt văn bản bằng cách tính toán điểm tương đồng. text_encoder_2 ([`~transformers.T5EncoderModel`, `~transformers.VitsModel`]) : Bộ mã hóa văn bản đóng băng thứ hai. AudioLDM2 sử dụng bộ mã hóa của [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), cụ thể là biến thể [google/flan-t5-large](https://huggingface.co/google/flan-t5-large). Bộ mã hóa văn bản đóng băng thứ hai dùng cho TTS. AudioLDM2 sử dụng bộ mã hóa của [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel). projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/v0.43.0/vi/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : Một mô hình đã được huấn luyện, dùng để chiếu tuyến tính các hidden-states từ hai mô hình text encoder thứ nhất và thứ hai, đồng thời chèn các embedding của token SOS và EOS đã học được. Các hidden-states đã được chiếu từ hai text encoder này sẽ được nối (concatenate) lại với nhau để tạo thành đầu vào cho mô hình ngôn ngữ. Một Learned Position Embedding cho các hidden-states của Vits language_model ([GPT2Model](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/gpt2#transformers.GPT2Model)) : Một mô hình ngôn ngữ tự hồi quy được sử dụng để tạo ra một chuỗi các hidden-state có điều kiện dựa trên các đầu ra đã được chiếu từ hai bộ mã hóa văn bản. tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/led#transformers.RobertaTokenizer)) : Tokenizer để tách token văn bản cho text-encoder đóng băng đầu tiên. tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : Tokenizer để tokenize văn bản cho text-encoder đóng băng thứ hai. feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clap#transformers.ClapFeatureExtractor)) : Bộ trích xuất đặc trưng để tiền xử lý các dạng sóng âm thanh đã tạo thành các phổ log-mel nhằm chấm điểm tự động. unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Một `UNet2DConditionModel` để khử nhiễu các latents âm thanh đã mã hóa. scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/vi/api/schedulers/overview#diffusers.SchedulerMixin)) : Một scheduler được sử dụng kết hợp với `unet` để khử nhiễu các latents âm thanh đã mã hóa. Có thể là một trong [DDIMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), hoặc [PNDMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/pndm#diffusers.PNDMScheduler). vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/speecht5#transformers.SpeechT5HifiGan)) : Vocoder của lớp `SpeechT5HifiGan` để chuyển đổi các latent mel-spectrogram thành dạng sóng âm thanh cuối cùng. Pipeline để tạo audio từ văn bản sử dụng AudioLDM2. Mô hình này kế thừa từ [DiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline). Xem tài liệu của lớp cha để biết các phương thức chung được triển khai cho tất cả các pipeline (tải xuống, lưu, chạy trên một thiết bị cụ thể, v.v.). #### __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') ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L844) **Tham số:** prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn tạo âm thanh. Nếu không được định nghĩa, bạn cần truyền `prompt_embeds`. transcription (`str` hoặc `list[str]`, *tùy chọn*) --\ Bản ghi âm cho văn bản thành giọng nói. audio_length_in_s (`int`, *tuỳ chọn*, mặc định là 10.24) : Độ dài của mẫu âm thanh được tạo ra, tính bằng giây. num_inference_steps (`int`, *optional*, mặc định là 200) : Số bước khử nhiễu. Số bước khử nhiễu nhiều hơn thường dẫn đến âm thanh có chất lượng cao hơn, đổi lại là suy luận chậm hơn. guidance_scale (`float`, *optional*, mặc định là 3.5) : Giá trị guidance scale cao hơn khuyến khích mô hình tạo ra âm thanh gắn kết chặt chẽ với `prompt` văn bản, với cái giá là chất lượng âm thanh thấp hơn. Guidance scale được kích hoạt khi `guidance_scale > 1`. negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn những gì không nên bao gồm trong quá trình tạo âm thanh. Nếu không được định nghĩa, bạn cần truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (`guidance_scale < 1`). num_waveforms_per_prompt (`int`, *optional*, mặc định là 1) : Số lượng waveform cần tạo cho mỗi prompt. Nếu `num_waveforms_per_prompt > 1`, thì quá trình chấm điểm tự động sẽ được thực hiện giữa các đầu ra đã tạo và prompt văn bản. Việc chấm điểm này xếp hạng các waveform đã tạo dựa trên độ tương đồng cosine của chúng với đầu vào văn bản trong không gian nhúng chung text-audio. eta (`float`, *tuỳ chọn*, mặc định là 0.0) : Tương ứng với tham số eta (η) trong bài báo [DDIM](https://huggingface.co/papers/2010.02502). Chỉ áp dụng cho [DDIMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/ddim#diffusers.DDIMScheduler) và bị bỏ qua ở các trình lập lịch khác. generator (`torch.Generator` hoặc `list[torch.Generator]`, *tùy chọn*) : Một [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) để đảm bảo quá trình sinh là tất định. latents (`torch.Tensor`, *tùy chọn*) : Các latents nhiễu được tạo trước, lấy mẫu từ phân phối Gaussian, dùng làm đầu vào cho việc tạo spectrogram. Có thể dùng để tinh chỉnh cùng một quá trình tạo với các prompt khác nhau. Nếu không được cung cấp, một tensor latents sẽ được tạo bằng cách lấy mẫu sử dụng `generator` ngẫu nhiên được cung cấp. prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản (trọng số prompt). Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`. negative_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản (trọng số prompt). Nếu không được cung cấp, `negative_prompt_embeds` sẽ được tạo từ đối số đầu vào `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản được tạo trước từ mô hình ngôn ngữ GPT2. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm được tạo trước từ mô hình ngôn ngữ GPT2. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, negative_prompt_embeds sẽ được tính toán từ đối số đầu vào `negative_prompt`. attention_mask (`torch.LongTensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) đã được tính trước để áp dụng cho `prompt_embeds`. Nếu không được cung cấp, mặt nạ chú ý sẽ được tính từ đối số đầu vào `prompt`. negative_attention_mask (`torch.LongTensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) đã được tính trước để áp dụng cho `negative_prompt_embeds`. Nếu không được cung cấp, mặt nạ chú ý sẽ được tính từ đối số đầu vào `negative_prompt`. max_new_tokens (`int`, *tuỳ chọn*, mặc định là None) : Số lượng token mới cần tạo bằng mô hình ngôn ngữ GPT2. Nếu không được cung cấp, số lượng token sẽ được lấy từ cấu hình của mô hình. return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) thay vì một tuple thông thường hay không. callback (`Callable`, *tùy chọn*) : Một hàm được gọi mỗi `callback_steps` bước trong quá trình suy luận. Hàm này được gọi với các đối số sau: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *optional*, mặc định là 1) : Tần suất gọi hàm `callback`. Nếu không được chỉ định, callback sẽ được gọi ở mỗi bước. cross_attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttentionProcessor` như đã định nghĩa trong [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). output_type (`str`, *tùy chọn*, mặc định là `"np"`) : Định dạng đầu ra của âm thanh được tạo ra. Chọn `"np"` để trả về `np.ndarray` của NumPy hoặc `"pt"` để trả về đối tượng `torch.Tensor` của PyTorch. Đặt thành `"latent"` để trả về đầu ra của mô hình khuếch tán tiềm ẩn (LDM). **Trả về:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) hoặc `tuple` Nếu `return_dict` là `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) sẽ được trả về, ngược lại một `tuple` sẽ được trả về trong đó phần tử đầu tiên là một danh sách chứa âm thanh đã tạo. Hàm gọi call của pipeline để tạo nội dung. Ví dụ: ```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') ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226) Tải tất cả các mô hình xuống CPU bằng accelerate, giảm mức sử dụng bộ nhớ với tác động thấp đến hiệu suất. So với `enable_sequential_cpu_offload`, phương pháp này di chuyển toàn bộ một mô hình lên GPU mỗi khi phương thức `forward` của nó được gọi, và mô hình sẽ ở lại trên GPU cho đến khi mô hình tiếp theo chạy. Mức tiết kiệm bộ nhớ thấp hơn so với `enable_sequential_cpu_offload`, nhưng hiệu suất tốt hơn nhiều nhờ việc thực hiện lặp lại của `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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L331) **Tham số:** prompt (`str` hoặc `list[str]`, *tùy chọn*) : prompt cần được mã hóa transcription (`str` hoặc `list[str]`) : bản chuyển đổi văn bản thành giọng nói device (`torch.device`) : thiết bị torch num_waveforms_per_prompt (`int`) : số lượng waveform cần được tạo cho mỗi prompt do_classifier_free_guidance (`bool`) : có sử dụng classifier free guidance hay không negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt không được dùng để hướng dẫn việc tạo âm thanh. Nếu không được định nghĩa, cần truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (tức là bị bỏ qua nếu `guidance_scale` nhỏ hơn `1`). prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tính trước từ mô hình Flan T5. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tính từ đối số đầu vào `prompt`. negative_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm đã được tính trước từ mô hình Flan T5. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, negative_prompt_embeds sẽ được tính từ đối số đầu vào `negative_prompt`. generated_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản được tạo trước từ mô hình ngôn ngữ GPT2. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`. negative_generated_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm được tạo trước từ mô hình ngôn ngữ GPT2. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *ví dụ* như trọng số của prompt. Nếu không được cung cấp, negative_prompt_embeds sẽ được tính toán từ đối số đầu vào `negative_prompt`. attention_mask (`torch.LongTensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) đã được tính trước để áp dụng cho `prompt_embeds`. Nếu không được cung cấp, mặt nạ chú ý sẽ được tính từ đối số đầu vào `prompt`. negative_attention_mask (`torch.LongTensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) đã được tính trước để áp dụng cho `negative_prompt_embeds`. Nếu không được cung cấp, mặt nạ chú ý sẽ được tính từ đối số đầu vào `negative_prompt`. max_new_tokens (`int`, *tuỳ chọn*, mặc định là None) : Số lượng token mới cần tạo bằng mô hình ngôn ngữ GPT2. **Trả về:** prompt_embeds (`torch.Tensor`) Text embeddings từ mô hình Flan T5. attention_mask (`torch.LongTensor`): Attention mask được áp dụng cho `prompt_embeds`. generated_prompt_embeds (`torch.Tensor`): Text embeddings được tạo ra từ mô hình ngôn ngữ GPT2. Mã hóa prompt thành các trạng thái ẩn của text encoder. Ví dụ: ```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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L278) **Tham số:** inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi được sử dụng làm prompt cho quá trình sinh. max_new_tokens (`int`) : Số lượng token mới cần tạo. model_kwargs (`dict[str, Any]`, *tùy chọn*) : Tham số hóa ad hoc cho các kwargs cụ thể của model bổ sung, sẽ được chuyển tiếp đến hàm `forward` của model. **Returns:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`) Dãy các hidden-states được tạo ra. Tạo ra một chuỗi hidden-states từ mô hình ngôn ngữ, có điều kiện dựa trên các đầu vào 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60) **Tham số:** text_encoder_dim (`int`) : Độ cao của các vector nhúng văn bản từ trình mã hóa văn bản đầu tiên (CLAP). text_encoder_1_dim (`int`) : Số chiều của các vector nhúng văn bản từ trình mã hóa văn bản thứ hai (T5 hoặc VITS). langauge_model_dim (`int`) : Số chiều của các vector nhúng văn bản từ mô hình ngôn ngữ (GPT2). Một mô hình chiếu tuyến tính đơn giản để ánh xạ hai vector nhúng văn bản vào một không gian ẩn chung. Nó cũng chèn các vector nhúng đã học vào đầu và cuối của mỗi chuỗi vector nhúng văn bản tương ứng. Mỗi biến được thêm hậu tố `_1` chỉ đến phần tử tương ứng với bộ mã hóa văn bản thứ hai. Ngược lại, chúng đến từ bộ mã hóa thứ nhất. #### 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L104) **Tham số:** hidden_states (`torch.Tensor` có shape `(batch_size, sequence_length, text_encoder_dim)`, *tùy chọn*) : Các embedding văn bản từ text encoder đầu tiên (CLAP). hidden_states_1 (`torch.Tensor` có shape `(batch_size, sequence_length_1, text_encoder_1_dim)`, *tùy chọn*) : Các embedding văn bản từ text encoder thứ hai (T5 hoặc VITS). attention_mask (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ chú ý cho `hidden_states`. attention_mask_1 (`torch.LongTensor` có hình dạng `(batch_size, sequence_length_1)`, *tùy chọn*) : Mặt nạ chú ý cho `hidden_states_1`. **Trả về:** `AudioLDM2ProjectionModelOutput` Các vector nhúng văn bản đã được chiếu của cả hai bộ mã hóa văn bản, được nối theo chiều chuỗi, cùng với mặt nạ chú ý kết hợp của chúng. ## 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45) **Tham số:** sample_size (`int` hoặc `tuple[int, int]`, *tùy chọn*, mặc định là `None`) : Chiều cao và chiều rộng của mẫu đầu vào/đầu ra. in_channels (`int`, *tuỳ chọn*, mặc định là 4) : Số kênh trong mẫu đầu vào. out_channels (`int`, *tuỳ chọn*, mặc định là 4) : Số kênh trong đầu ra. flip_sin_to_cos (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đảo sin thành cos trong nhúng thời gian hay không. freq_shift (`int`, *optional*, mặc định là 0) : Độ dịch tần số cần áp dụng cho nhúng thời gian. down_block_types (`tuple[str]`, *tùy chọn*, mặc định là `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Bộ tuple các khối hạ mẫu (downsample) cần sử dụng. mid_block_type (`str`, *tùy chọn*, mặc định là `"UNetMidBlock2DCrossAttn"`) : Kiểu khối cho phần giữa của UNet, với AudioLDM2 chỉ có thể là `UNetMidBlock2DCrossAttn`. up_block_types (`tuple[str]`, *tùy chọn*, mặc định là `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Bộ tuple các khối upsample cần sử dụng. only_cross_attention (`bool` hoặc `tuple[bool]`, *tuỳ chọn*, mặc định là `False`) : Có bao gồm self-attention trong các khối transformer cơ bản hay không, xem `BasicTransformerBlock`. block_out_channels (`tuple[int]`, *optional*, mặc định là `(320, 640, 1280, 1280)`) : Bộ tuple các kênh đầu ra cho mỗi khối. layers_per_block (`int`, *tuỳ chọn*, mặc định là 2) : Số lượng lớp trong mỗi khối. downsample_padding (`int`, *optional*, mặc định là 1) : Padding được sử dụng cho phép tích chập hạ mẫu. mid_block_scale_factor (`float`, *tuỳ chọn*, mặc định là 1.0) : Hệ số tỷ lệ cần sử dụng cho khối giữa. act_fn (`str`, *tùy chọn*, mặc định là `"silu"`) : Hàm kích hoạt cần sử dụng. norm_num_groups (`int`, *optional*, mặc định là 32) : Số nhóm được sử dụng cho phép chuẩn hóa. Nếu `None`, các lớp chuẩn hóa và kích hoạt sẽ bị bỏ qua trong xử lý hậu kỳ. norm_eps (`float`, *tuỳ chọn*, mặc định là 1e-5) : Epsilon được sử dụng cho phép chuẩn hóa. cross_attention_dim (`int` hoặc `tuple[int]`, *tùy chọn*, mặc định là 1280) : Kích thước của các đặc trưng chú ý chéo (cross attention). transformer_layers_per_block (`int` hoặc `tuple[int]`, *tuỳ chọn*, mặc định là 1) : Số lượng khối transformer có kiểu `BasicTransformerBlock`. Chỉ liên quan đến `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`. attention_head_dim (`int`, *tuỳ chọn*, mặc định là 8) : Kích thước của các đầu chú ý. num_attention_heads (`int`, *tuỳ chọn*) : Số lượng đầu chú ý. Nếu không được định nghĩa, mặc định là `attention_head_dim` resnet_time_scale_shift (`str`, *tùy chọn*, mặc định là `"default"`) : Cấu hình dịch chuyển thang thời gian cho các khối ResNet (xem `ResnetBlock2D`). Chọn từ `default` hoặc `scale_shift`. class_embed_type (`str`, *tùy chọn*, mặc định là `None`) : Loại class embedding được sử dụng, cuối cùng sẽ được cộng với các time embeddings. Chọn từ `None`, `"timestep"`, `"identity"`, `"projection"` hoặc `"simple_projection"`. num_class_embeds (`int`, *tuỳ chọn*, mặc định là `None`) : Kích thước đầu vào của ma trận nhúng có thể học được để chiếu sang `time_embed_dim`, khi thực hiện điều kiện theo lớp với `class_embed_type` bằng `None`. time_embedding_type (`str`, *tùy chọn*, mặc định là `positional`) : Kiểu nhúng vị trí cần sử dụng cho các bước thời gian. Chọn từ `positional` hoặc `fourier`. time_embedding_dim (`int`, *tuỳ chọn*, mặc định là `None`) : Một giá trị ghi đè tuỳ chọn cho chiều của time embedding đã được chiếu (projected). time_embedding_act_fn (`str`, *tùy chọn*, mặc định là `None`) : Hàm kích hoạt tùy chọn để chỉ sử dụng một lần trên các nhúng thời gian trước khi chúng được truyền đến phần còn lại của UNet. Chọn từ `silu`, `mish`, `gelu` và `swish`. timestep_post_act (`str`, *tùy chọn*, mặc định là `None`) : Hàm kích hoạt thứ hai được sử dụng trong nhúng bước thời gian. Chọn từ `silu`, `mish` và `gelu`. time_cond_proj_dim (`int`, *tuỳ chọn*, mặc định là `None`) : Kích thước của lớp `cond_proj` trong phần nhúng bước thời gian (timestep embedding). conv_in_kernel (`int`, *tuỳ chọn*, mặc định là `3`) : Kích thước kernel của lớp `conv_in`. conv_out_kernel (`int`, *tuỳ chọn*, mặc định là `3`) : Kích thước kernel của lớp `conv_out`. projection_class_embeddings_input_dim (`int`, *optional*) : Kích thước của đầu vào `class_labels` khi `class_embed_type="projection"`. Bắt buộc khi `class_embed_type="projection"`. class_embeddings_concat (`bool`, *tùy chọn*, mặc định là `False`) : Có nối các embedding thời gian với các embedding lớp hay không. Mô hình 2D UNet có điều kiện, nhận vào một mẫu nhiễu, trạng thái điều kiện và một bước thời gian, sau đó trả về một mẫu đầu ra có cùng hình dạng. So với [UNet2DConditionModel](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel) thông thường, biến thể này tùy chọn bao gồm một lớp self-attention bổ sung trong mỗi khối Transformer, cũng như nhiều lớp cross-attention. Nó cũng cho phép tối đa hai embedding cross-attention, `encoder_hidden_states` và `encoder_hidden_states_1`. Mô hình này kế thừa từ [ModelMixin](/docs/diffusers/v0.43.0/vi/api/models/overview#diffusers.ModelMixin). Hãy xem tài liệu của lớp cha để biết các phương thức chung được triển khai cho tất cả các mô hình (chẳng hạn như tải xuống hoặc lưu trữ). #### 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494) **Tham số:** sample (`torch.Tensor`) : Tensor đầu vào có nhiễu với hình dạng `(batch, channel, height, width)` như sau. timestep (`torch.Tensor` hoặc `float` hoặc `int`) : Số bước thời gian để khử nhiễu cho một đầu vào. encoder_hidden_states (`torch.Tensor`) : Trạng thái ẩn của bộ mã hóa với hình dạng `(batch, sequence_length, feature_dim)`. encoder_attention_mask (`torch.Tensor`) : Một mặt nạ cross-attention có hình dạng `(batch, sequence_length)` được áp dụng cho `encoder_hidden_states`. Nếu `True`, mặt nạ được giữ lại; ngược lại, nếu `False`, nó sẽ bị loại bỏ. Mặt nạ sẽ được chuyển đổi thành một bias, thêm các giá trị âm lớn vào các điểm chú ý tương ứng với các token "loại bỏ". return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một [UNet2DConditionOutput](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) thay vì một tuple thông thường hay không. cross_attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttnProcessor`. encoder_hidden_states_1 (`torch.Tensor`, *tùy chọn*) : Một tập hợp các trạng thái ẩn của bộ mã hóa thứ hai có hình dạng `(batch, sequence_length_2, feature_dim_2)`. Có thể được sử dụng để điều kiện hóa mô hình dựa trên một tập hợp các vector nhúng khác với `encoder_hidden_states`. encoder_attention_mask_1 (`torch.Tensor`, *tùy chọn*) : Một mặt nạ chú ý chéo (cross-attention mask) có hình dạng `(batch, sequence_length_2)` được áp dụng cho `encoder_hidden_states_1`. Nếu `True`, mặt nạ được giữ lại; ngược lại, nếu `False`, nó sẽ bị loại bỏ. Mặt nạ sẽ được chuyển đổi thành một độ lệch (bias), thêm các giá trị âm lớn vào các điểm chú ý (attention scores) tương ứng với các token "loại bỏ". **Trả về:** [UNet2DConditionOutput](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) hoặc `tuple` Nếu `return_dict` là True, một [UNet2DConditionOutput](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) sẽ được trả về, ngược lại một `tuple` sẽ được trả về trong đó phần tử đầu tiên là tensor mẫu. Phương thức forward của [AudioLDM2UNet2DConditionModel](/docs/diffusers/v0.43.0/vi/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel). ## AudioPipelineOutput[[diffusers.AudioPipelineOutput]] #### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]] ```python diffusers.AudioPipelineOutput(audios: ndarray) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L149) **Tham số:** audios (`np.ndarray`) : Danh sách các mẫu âm thanh đã khử nhiễu của một mảng NumPy có hình dạng `(batch_size, num_channels, sample_rate)`. Lớp đầu ra cho các pipeline âm thanh.