# AudioLDM 2 AudioLDM 2는 Haohe Liu 외의 연구자들이 [AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining](https://huggingface.co/papers/2308.05734)에서 제안했습니다. AudioLDM 2는 텍스트 프롬프트를 입력으로 받아 이에 해당하는 오디오를 예측합니다. 텍스트 조건부 효과음, 인간 음성, 음악을 생성할 수 있습니다. [Stable Diffusion](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/overview)에서 영감을 받은 AudioLDM 2는 텍스트 임베딩에서 연속적인 오디오 표현을 학습하는 텍스트-오디오 _latent diffusion model (LDM)_입니다. 프롬프트 입력으로부터 텍스트 임베딩을 계산하기 위해 두 가지 텍스트 인코더 모델이 사용됩니다: [CLAP](https://huggingface.co/docs/transformers/main/en/model_doc/clap)의 텍스트 브랜치와 [Flan-T5](https://huggingface.co/docs/transformers/main/en/model_doc/flan-t5)의 인코더입니다. 이러한 텍스트 임베딩은 [AudioLDM2ProjectionModel](https://huggingface.co/docs/diffusers/main/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)에 의해 공유 임베딩 공간으로 투영됩니다. [GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2) _language model (LM)_은 투영된 CLAP 및 Flan-T5 임베딩을 조건으로 하여 8개의 새로운 임베딩 벡터를 자기회귀적으로 예측하는 데 사용됩니다. 생성된 임베딩 벡터와 Flan-T5 텍스트 임베딩은 LDM에서 크로스 어텐션 조건으로 사용됩니다. AudioLDM 2의 [UNet](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel)은 대부분의 다른 LDM이 하나의 크로스 어텐션 조건을 사용하는 것과 달리, **두 개의** 크로스 어텐션 임베딩을 입력으로 받는다는 점에서 독특합니다. 해당 논문의 초록은 다음과 같습니다: *음성, 음악, 효과음 등 다양한 유형의 오디오는 공통점을 공유하지만, 각 유형에 대한 모델 설계는 서로 크게 다를 수 있는 특정 목표와 편향을 신중하게 고려해야 합니다. 오디오 생성에 대한 통합된 관점을 한층 더 가까이 가져가기 위해, 이 논문은 음성, 음악, 효과음 생성에 동일한 학습 방법을 활용하는 프레임워크를 제안합니다. 제안된 프레임워크는 "오디오의 언어"(LOA)라고 불리는 오디오의 일반적 표현을 도입합니다. AudioMAE라는 자기지도 사전학습 표현 학습 모델을 기반으로, 모든 오디오를 LOA로 변환할 수 있습니다. 생성 과정에서 GPT-2 모델을 사용하여 모든 모달리티를 LOA로 변환하고, LOA를 조건으로 하는 잠재 확산 모델(latent diffusion model)로 자기지도 오디오 생성 학습을 수행합니다. 제안된 프레임워크는 컨텍스트 학습 능력과 재사용 가능한 자기지도 사전학습 AudioMAE 및 잠재 확산 모델과 같은 이점을 자연스럽게 제공합니다. 텍스트-오디오, 텍스트-음악, 텍스트-음성 생성의 주요 벤치마크에 대한 실험은 이전 접근 방식에 비해 최첨단 또는 경쟁력 있는 성능을 입증합니다. 코드, 사전학습 모델, 데모는 [이 https URL](https://audioldm.github.io/audioldm2)에서 사용할 수 있습니다.* 이 파이프라인은 [sanchit-gandhi](https://huggingface.co/sanchit-gandhi)와 [Nguyễn Công Tú Anh](https://github.com/tuanh123789)가 기여했습니다. 원본 코드베이스는 [haoheliu/audioldm2](https://github.com/haoheliu/audioldm2)에서 찾을 수 있습니다. ## 팁 ### 체크포인트 선택 AudioLDM2에는 세 가지 변형이 있습니다. 이 중 두 개의 체크포인트는 텍스트-오디오 생성이라는 일반적인 작업에 적용됩니다. 세 번째 체크포인트는 텍스트-음악 생성에만 학습되었습니다. 모든 체크포인트는 텍스트 인코더와 VAE의 모델 크기가 동일합니다. UNet의 크기와 깊이가 서로 다릅니다. 세 가지 체크포인트에 대한 세부 사항은 아래 표를 참조하세요: | 체크포인트 | 작업 | UNet 모델 크기 | 모델 전체 크기 | 학습 데이터 / h | |-----------------------------------------------------------------|---------------|-----------------|------------------|-------------------| | [audioldm2](https://huggingface.co/cvssp/audioldm2) | 텍스트-오디오 | 350M | 1.1B | 1150k | | [audioldm2-large](https://huggingface.co/cvssp/audioldm2-large) | 텍스트-오디오 | 750M | 1.5B | 1150k | | [audioldm2-music](https://huggingface.co/cvssp/audioldm2-music) | 텍스트-투-음악 | 350M | 1.1B | 665k | | [audioldm2-gigaspeech](https://huggingface.co/anhnct/audioldm2_gigaspeech) | 텍스트-음성 | 350M | 1.1B |10k | | [audioldm2-ljspeech](https://huggingface.co/anhnct/audioldm2_ljspeech) | 텍스트-음성 | 350M | 1.1B | | ### 프롬프트 구성 * 설명적인 프롬프트 입력이 가장 효과적입니다. 형용사를 사용하여 사운드를 설명하고(예: "high quality" 또는 "clear"), 프롬프트의 맥락을 구체적으로 지정하세요(예: "stream" 대신 "water stream in a forest"). * 모델이 익숙하지 않을 수 있는 구체적인 이름이나 추상적인 대상 대신 "cat"이나 "dog"와 같은 일반적인 용어를 사용하는 것이 좋습니다. * **negative prompt**를 사용하면 품질이 낮은 오디오에 해당하는 용어로부터 생성을 유도하여 생성된 waveforms의 품질을 크게 향상시킬 수 있습니다. "Low quality."를 negative prompt로 사용해 보세요. ### 추론 제어 * 예측된 오디오 샘플의 _품질_은 `num_inference_steps` 인자로 제어할 수 있습니다. 단계 수가 높을수록 추론 속도는 느려지지만 더 높은 품질의 오디오를 얻을 수 있습니다. * 예측된 오디오 샘플의 _길이_는 `audio_length_in_s` 인수를 변경하여 제어할 수 있습니다. ### 생성된 웨이브폼 평가: * seed에 따라 생성된 waveforms의 품질이 크게 달라질 수 있습니다. 만족스러운 생성 결과가 나올 때까지 다른 seed로 생성을 시도해 보세요. * `num_waveforms_per_prompt`을 1보다 큰 값으로 설정하면 한 번에 여러 웨이브폼을 생성할 수 있습니다. 생성된 웨이브폼과 프롬프트 텍스트 사이에 자동 점수가 매겨지며, 점수에 따라 오디오가 우수도순으로 정렬됩니다. 다음 예제는 aforementioned 팁을 활용하여 좋은 음악 및 음성 생성을 구성하는 방법을 보여줍니다: [예제](https://huggingface.co/docs/diffusers/main/en/api/pipelines/audioldm2#diffusers.AudioLDM2Pipeline.__call__.example). > [!TIP] > Scheduler의 [가이드](../../using-diffusers/schedulers)를 확인하여 스케줄러의 속도와 품질 사이의 트레이드오프를 탐색하는 방법을 배우고, [파이프라인 간 구성 요소 재사용](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) 섹션을 확인하여 동일한 구성 요소를 여러 파이프라인에 효율적으로 로드하는 방법을 배워보세요. ## 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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L150) **매개변수:** vae ([AutoencoderKL](/docs/diffusers/main/ko/api/models/autoencoderkl#diffusers.AutoencoderKL)) : 이미지를 잠재 표현으로 인코딩하고 잠재 표현에서 이미지로 디코딩하는 Variational Auto-Encoder (VAE) 모델입니다. text_encoder ([ClapModel](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapModel)) : 첫 번째 고정된 텍스트 인코더입니다. AudioLDM2는 오디오-텍스트 결합 임베딩 모델인 [CLAP](https://huggingface.co/docs/transformers/model_doc/clap#transformers.CLAPTextModelWithProjection), 구체적으로 [laion/clap-htsat-unfused](https://huggingface.co/laion/clap-htsat-unfused) 변형을 사용합니다. 텍스트 브랜치는 텍스트 프롬프트를 프롬프트 임베딩으로 인코딩하는 데 사용됩니다. 전체 오디오-텍스트 모델은 유사도 점수를 계산하여 생성된 웨이브폼을 텍스트 프롬프트와 비교하여 순위를 매기는 데 사용됩니다. text_encoder_2 ([`~transformers.T5EncoderModel`, `~transformers.VitsModel`]) : 두 번째 고정된 텍스트 인코더. AudioLDM2는 [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel) 인코더, 구체적으로 [google/flan-t5-large](https://huggingface.co/google/flan-t5-large) 변형을 사용합니다. TTS에 사용되는 두 번째 고정된 텍스트 인코더입니다. AudioLDM2는 [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel) 인코더를 사용합니다. projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/ko/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : 첫 번째 및 두 번째 텍스트 인코더 모델의 hidden-states를 선형적으로 투사하고 학습된 SOS 및 EOS 토큰 임베딩을 삽입하는 데 사용되는 학습된 모델입니다. 두 텍스트 인코더에서 투사된 hidden-states가 연결되어 언어 모델의 입력을 형성합니다. Vits hidden-states에 대한 학습된 위치 임베딩 language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.GPT2Model)) : 두 텍스트 인코더의 투영된 출력을 조건으로 하여 hidden-states 시퀀스를 생성하는 자동 회귀 언어 모델입니다. tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : 첫 번째 동결된 텍스트 인코더에 사용할 텍스트를 토큰화하는 토크나이저입니다. tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : 두 번째 고정된 text-encoder에 사용할 텍스트를 토큰화하는 Tokenizer. feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : 자동 점수를 위해 생성된 오디오 웨이브폼을 로그-멜 스펙트로그램으로 전처리하는 피처 추출기. unet ([UNet2DConditionModel](/docs/diffusers/main/ko/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 인코딩된 오디오 라텐트를 디노이즈하기 위한 `UNet2DConditionModel`. scheduler ([SchedulerMixin](/docs/diffusers/main/ko/api/schedulers/overview#diffusers.SchedulerMixin)) : `unet`와 함께 사용되어 인코딩된 오디오 잠재를 디노이즈하는 스케줄러입니다. [DDIMScheduler](/docs/diffusers/main/ko/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/ko/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), 또는 [PNDMScheduler](/docs/diffusers/main/ko/api/schedulers/pndm#diffusers.PNDMScheduler) 중 하나일 수 있습니다. vocoder ([SpeechT5HifiGan](https://huggingface.co/docs/transformers/main/en/model_doc/speecht5#transformers.SpeechT5HifiGan)) : 멜 스펙트로그램 잠재를 최종 오디오 웨이브폼으로 변환하는 `SpeechT5HifiGan` 클래스의 보코더. AudioLDM2를 사용한 텍스트-오디오 생성을 위한 Pipeline 이 모델은 [DiffusionPipeline](/docs/diffusers/main/ko/api/pipelines/overview#diffusers.DiffusionPipeline)에서 상속됩니다. 모든 파이프라인에 대해 구현된 일반적 메서드(다운로드, 저장, 특정 디바이스에서 실행 등)에 대해서는 상위 클래스 문서를 확인하세요. #### __호출__[[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') ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L842) **매개변수:** prompt (`str` 또는 `list[str]`, *선택 사항*) : 오디오 생성을 안내할 프롬프트입니다. 정의되지 않은 경우 `prompt_embeds`를 전달해야 합니다. transcription (`str` 또는 `list[str]`, *선택*) --\ 텍스트를 음성으로 변환할 전사 텍스트. audio_length_in_s (`int`, *선택 사항*, 기본값 10.24) : 생성된 오디오 샘플의 길이(초). num_inference_steps (`int`, *선택 사항*, 기본값 200) : 디노이징 단계의 수입니다. 디노이징 단계를 늘리면 추론 속도가 느려지는 대신 일반적으로 더 높은 품질의 오디오를 얻을 수 있습니다. guidance_scale (`float`, *선택 사항*, 기본값 3.5) : guidance scale 값이 높을수록 모델은 텍스트 `prompt`와 밀접하게 연결된 오디오를 생성하도록 유도되지만, 음질은 낮아질 수 있습니다. `guidance_scale > 1`일 때 guidance scale이 활성화됩니다. negative_prompt (`str` 또는 `list[str]`, *선택 사항*) : 오디오 생성에서 포함하지 않을 내용을 안내하는 프롬프트입니다. 정의되지 않은 경우 대신 `negative_prompt_embeds`를 전달해야 합니다. 가이던스를 사용하지 않을 때(`guidance_scale < 1`)에는 무시됩니다. num_waveforms_per_prompt (`int`, *선택 사항*, 기본값 1) : 프롬프트당 생성할 웨이브폼의 수입니다. `num_waveforms_per_prompt > 1`인 경우, 생성된 출력과 텍스트 프롬프트 사이에 자동 스코어링이 수행됩니다. 이 스코어링은 텍스트-오디오 결합 임베딩 공간에서 텍스트 입력과의 코사인 유사도를 기준으로 생성된 웨이브폼을 랭킹합니다. eta (`float`, *선택 사항*, 기본값 0.0) : [DDIM](https://huggingface.co/papers/2010.02502) 논문에서 정의한 파라미터 eta (η)에 해당합니다. [DDIMScheduler](/docs/diffusers/main/ko/api/schedulers/ddim#diffusers.DDIMScheduler)에만 적용되며, 다른 스케줄러에서는 무시됩니다. generator (`torch.Generator` 또는 `list[torch.Generator]`, *선택 사항*) : 생성을 결정적으로 만들기 위한 [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html)입니다. latents (`torch.Tensor`, *선택 사항*) : 가우시안 분포에서 샘플링된 사전 생성된 노이즈된 latents로, 스펙트로그램 생성의 입력으로 사용됩니다. 동일한 생성을 다른 프롬프트로 조정하는 데 사용할 수 있습니다. 제공되지 않으면, 제공된 랜덤 `generator`를 사용하여 샘플링하여 latents 텐서를 생성합니다. prompt_embeds (`torch.Tensor`, *선택 사항*) : 미리 생성된 텍스트 임베딩입니다. 텍스트 입력(프롬프트 가중치)을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `prompt` 입력 인자에서 텍스트 임베딩이 생성됩니다. negative_prompt_embeds (`torch.Tensor`, *선택 사항*) : 미리 생성된 부정 텍스트 임베딩입니다. 텍스트 입력(프롬프트 가중치)을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `negative_prompt` 입력 인수에서 `negative_prompt_embeds`가 생성됩니다. generated_prompt_embeds (`torch.Tensor`, *optional*) : GPT2 언어 모델에서 생성된 사전 생성된 텍스트 임베딩입니다. *e.g.* 프롬프트 가중치와 같이 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `prompt` 입력 인자에서 텍스트 임베딩이 생성됩니다. negative_generated_prompt_embeds (`torch.Tensor`, *선택 사항*) : GPT2 언어 모델에서 사전 생성된 부정 텍스트 임베딩입니다. *예를 들어* 프롬프트 가중치 조정과 같이 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `negative_prompt` 입력 인자로부터 negative_prompt_embeds가 계산됩니다. attention_mask (`torch.LongTensor`, *선택 사항*) : `prompt_embeds`에 적용할 사전 계산된 attention mask입니다. 제공되지 않으면 `prompt` 입력 인자로부터 attention mask가 계산됩니다. negative_attention_mask (`torch.LongTensor`, *선택 사항*) : `negative_prompt_embeds`에 적용할 사전 계산된 attention mask입니다. 제공되지 않으면 `negative_prompt` 입력 인수로부터 attention mask가 계산됩니다. max_new_tokens (`int`, *선택 사항*, 기본값 None) : GPT2 언어 모델로 생성할 새 토큰의 수입니다. 제공되지 않으면 모델의 config에서 토큰 수를 가져옵니다. return_dict (`bool`, *선택 사항*, 기본값 `True`) : 일반 튜플 대신 [StableDiffusionPipelineOutput](/docs/diffusers/main/ko/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput)을 반환할지 여부. callback (`Callable`, *선택 사항*) : 추론 중 `callback_steps` 단계마다 호출되는 함수입니다. 이 함수는 다음 인수를 받아 호출됩니다: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *선택 사항*, 기본값 1) : `callback` 함수가 호출되는 주기입니다. 지정하지 않으면 모든 단계에서 콜백이 호출됩니다. cross_attention_kwargs (`dict`, *선택 사항*) : 지정된 경우 [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py)에서 정의된 `AttentionProcessor`로 전달되는 kwargs 사전입니다. output_type (`str`, *선택 사항*, 기본값 `"np"`) : 생성된 오디오의 출력 형식입니다. NumPy `np.ndarray`를 반환하려면 `"np"`를, PyTorch `torch.Tensor` 객체를 반환하려면 `"pt"`를 선택합니다. latent diffusion model (LDM) 출력을 반환하려면 `"latent"`로 설정합니다. **반환값:** [StableDiffusionPipelineOutput](/docs/diffusers/main/ko/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) 또는 `tuple` `return_dict`가 `True`인 경우 [StableDiffusionPipelineOutput](/docs/diffusers/main/ko/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput)가 반환되고, 그렇지 않으면 생성된 오디오를 포함하는 리스트가 첫 번째 요소인 `tuple`이 반환됩니다. 생성을 위한 pipeline의 호출 함수. 예: ```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') ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L226) accelerate를 사용하여 모든 모델을 CPU로 오프로드하여 성능에 미치는 영향은 적으면서 메모리 사용량을 줄입니다. `enable_sequential_cpu_offload`와 비교하면, 이 메서드는 `forward` 메서드가 호출될 때 한 번에 하나의 모델을 GPU로 이동하며, 다음 모델이 실행될 때까지 해당 모델은 GPU에 유지됩니다. `enable_sequential_cpu_offload`를 사용할 때보다 메모리 절감 효과는 낮지만, `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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L329) **매개변수:** prompt (`str` 또는 `list[str]`, *선택 사항*) : 인코딩할 프롬프트 transcription (`str` 또는 `list[str]`) : 텍스트를 음성으로 변환한 결과 device (`torch.device`) : torch 디바이스 num_waveforms_per_prompt (`int`) : 프롬프트당 생성할 웨이브폼의 수 do_classifier_free_guidance (`bool`) : classifier free guidance를 사용할지 여부 negative_prompt (`str` 또는 `list[str]`, *선택 사항*) : 오디오 생성을 안내하지 않을 프롬프트입니다. 정의되지 않은 경우 대신 `negative_prompt_embeds`를 전달해야 합니다. 가이던스를 사용하지 않는 경우 무시됩니다(즉, `guidance_scale`이 `1`보다 작은 경우 무시됩니다). prompt_embeds (`torch.Tensor`, *선택 사항*) : Flan T5 모델에서 사전 계산된 텍스트 임베딩입니다. *예를 들어* 프롬프트 가중치와 같은 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `prompt` 입력 인자에서 텍스트 임베딩이 계산됩니다. negative_prompt_embeds (`torch.Tensor`, *선택 사항*) : Flan T5 모델에서 사전 계산된 부정 텍스트 임베딩입니다. *예를 들어* 프롬프트 가중치 조정과 같이 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `negative_prompt` 입력 인자로부터 negative_prompt_embeds가 계산됩니다. generated_prompt_embeds (`torch.Tensor`, *optional*) : GPT2 언어 모델에서 생성된 사전 생성된 텍스트 임베딩입니다. *e.g.* 프롬프트 가중치와 같이 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `prompt` 입력 인자에서 텍스트 임베딩이 생성됩니다. negative_generated_prompt_embeds (`torch.Tensor`, *선택 사항*) : GPT2 언어 모델에서 사전 생성된 부정 텍스트 임베딩입니다. *예를 들어* 프롬프트 가중치 조정과 같이 텍스트 입력을 쉽게 조정하는 데 사용할 수 있습니다. 제공되지 않으면 `negative_prompt` 입력 인자로부터 negative_prompt_embeds가 계산됩니다. attention_mask (`torch.LongTensor`, *선택 사항*) : `prompt_embeds`에 적용할 사전 계산된 attention mask입니다. 제공되지 않으면 `prompt` 입력 인자로부터 attention mask가 계산됩니다. negative_attention_mask (`torch.LongTensor`, *선택 사항*) : `negative_prompt_embeds`에 적용할 사전 계산된 attention mask입니다. 제공되지 않으면 `negative_prompt` 입력 인수로부터 attention mask가 계산됩니다. max_new_tokens (`int`, *선택 사항*, 기본값 None) : GPT2 언어 모델로 생성할 새 토큰의 수입니다. **반환값:** prompt_embeds (`torch.Tensor`) Flan T5 모델에서 생성된 텍스트 임베딩. attention_mask (`torch.LongTensor`): `prompt_embeds`에 적용할 어텐션 마스크. generated_prompt_embeds (`torch.Tensor`): GPT2 언어 모델에서 생성된 텍스트 임베딩. 프롬프트를 텍스트 인코더의 히든 상태로 인코딩합니다. 예: ```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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L276) **매개변수:** inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) : 생성을 위한 프롬프트로 사용되는 시퀀스. max_new_tokens (`int`) : 생성할 새 토큰의 수. model_kwargs (`dict[str, Any]`, *선택*) : 모델의 `forward` 함수로 전달될 추가적인 모델 특정 kwargs를 임의로 매개변수화합니다. **반환값:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`) 생성된 hidden-states의 시퀀스. 임베딩 입력을 조건으로 삼아 언어 모델에서 hidden-states 시퀀스를 생성합니다. ## 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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L60) **매개변수:** text_encoder_dim (`int`) : 첫 번째 텍스트 인코더(CLAP)에서 생성된 텍스트 임베딩의 차원 text_encoder_1_dim (`int`) : 두 번째 텍스트 인코더(T5 또는 VITS)에서 생성된 텍스트 임베딩의 차원. langauge_model_dim (`int`) : 언어 모델(GPT2)의 텍스트 임베딩 차원 두 텍스트 임베딩을 공유된 잠재 공간으로 매핑하는 단순한 선형 투영 모델입니다. 또한 각 텍스트 임베딩 시퀀스의 시작과 끝에 학습된 임베딩 벡터를 각각 삽입합니다. `_1`로 끝나는 각 변수는 두 번째 텍스트 인코더에 해당하는 것을 나타냅니다. 그렇지 않은 경우, 해당 변수는 첫 번째 텍스트 인코더에서 가져온 것입니다. #### 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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_audioldm2.py#L104) **매개변수:** hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, text_encoder_dim)`, *선택 사항*) : 첫 번째 텍스트 인코더(CLAP)에서 생성된 텍스트 임베딩. hidden_states_1 (`torch.Tensor`, shape `(batch_size, sequence_length_1, text_encoder_1_dim)`, *선택 사항*) : 두 번째 텍스트 인코더(T5 또는 VITS)에서 생성된 텍스트 임베딩. attention_mask (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : `hidden_states`에 대한 어텐션 마스크. attention_mask_1 (`torch.LongTensor`, shape `(batch_size, sequence_length_1)`, *선택 사항*) : `hidden_states_1`에 대한 attention mask입니다. **반환값:** `AudioLDM2ProjectionModelOutput` 두 텍스트 인코더의 투영된 텍스트 임베딩을 시퀀스 차원 방향으로 연결한 결과와, 결합된 어텐션 마스크입니다. ## 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 = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str = 'UNetMidBlock2DCrossAttn', up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple = (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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L45) **매개변수:** sample_size (`int` 또는 `tuple[int, int]`, *선택 사항*, 기본값 `None`) : 입력/출력 샘플의 높이와 너비. in_channels (`int`, *선택 사항*, 기본값 4) : 입력 샘플의 채널 수. out_channels (`int`, *선택 사항*, 기본값 4) : 출력의 채널 수. flip_sin_to_cos (`bool`, *선택 사항*, 기본값 `False`) : 시간 임베딩에서 sin을 cos로 전환할지 여부. freq_shift (`int`, *선택 사항*, 기본값 0) : 시간 임베딩에 적용할 주파수 시프트입니다. down_block_types (`tuple[str]`, *선택 사항*, 기본값 `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : 사용할 다운샘플 블록의 튜플입니다. mid_block_type (`str`, *선택 사항*, 기본값 `"UNetMidBlock2DCrossAttn"`) : UNet 중간 부분의 블록 유형입니다. AudioLDM2의 경우 `UNetMidBlock2DCrossAttn`만 사용할 수 있습니다. up_block_types (`tuple[str]`, *선택 사항*, 기본값 `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : 사용할 업샘플 블록의 튜플입니다. only_cross_attention (`bool` 또는 `tuple[bool]`, *선택 사항*, 기본값 `False`) : 기본 transformer 블록에 self-attention을 포함할지 여부, `BasicTransformerBlock` 참고. block_out_channels (`tuple[int]`, *선택 사항*, 기본값 `(320, 640, 1280, 1280)`) : 각 블록의 출력 채널 튜플입니다. layers_per_block (`int`, *선택 사항*, 기본값 2) : 블록당 레이어 수. downsample_padding (`int`, *선택 사항*, 기본값 1) : 다운샘플링 컨볼루션에 사용할 패딩입니다. mid_block_scale_factor (`float`, *선택 사항*, 기본값 1.0) : mid block에 사용할 스케일 팩터입니다. act_fn (`str`, *선택 사항*, 기본값 `"silu"`) : 사용할 활성화 함수입니다. norm_num_groups (`int`, *선택 사항*, 기본값 32) : 정규화에 사용할 그룹의 수입니다. `None`인 경우 후처리에서 정규화 및 활성화 레이어가 건너뜁니다. norm_eps (`float`, *선택 사항*, 기본값 1e-5) : 정규화에 사용할 epsilon입니다. cross_attention_dim (`int` 또는 `tuple[int]`, *선택 사항*, 기본값 1280) : 크로스 어텐션 특징의 차원입니다. transformer_layers_per_block (`int` 또는 `tuple[int]`, *선택 사항*, 기본값 1) : `BasicTransformerBlock` 유형의 transformer 블록 수입니다. `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`에만 관련이 있습니다. attention_head_dim (`int`, *선택 사항*, 기본값 8) : 어텐션 헤드의 차원입니다. num_attention_heads (`int`, *선택 사항*) : 어텐션 헤드의 수. 정의되지 않으면 기본값은 `attention_head_dim`입니다. resnet_time_scale_shift (`str`, *선택 사항*, 기본값 `"default"`) : ResNet 블록의 시간 스케일 시프트 설정(자세한 내용은 `ResnetBlock2D` 참조). `default` 또는 `scale_shift` 중 하나를 선택합니다. class_embed_type (`str`, *선택 사항*, 기본값 `None`) : 최종적으로 time embeddings와 합산되는 class embedding의 유형입니다. `None`, `"timestep"`, `"identity"`, `"projection"`, 또는 `"simple_projection"` 중 하나를 선택합니다. num_class_embeds (`int`, *선택 사항*, 기본값 `None`) : `class_embed_type`가 `None`인 경우 클래스 조건화를 수행할 때, 학습 가능한 임베딩 행렬의 입력 차원이며 이 값은 `time_embed_dim`으로 투사됩니다. time_embedding_type (`str`, *선택 사항*, 기본값 `positional`) : timesteps에 사용할 위치 임베딩의 유형입니다. `positional` 또는 `fourier` 중 하나를 선택합니다. time_embedding_dim (`int`, *선택 사항*, 기본값 `None`) : 투영된 시간 임베딩의 차원을 선택적으로 재정의합니다. time_embedding_act_fn (`str`, *선택 사항*, 기본값 `None`) : UNet의 나머지 부분으로 전달되기 전에 시간 임베딩에 한 번만 사용할 선택적 활성화 함수입니다. `silu`, `mish`, `gelu`, `swish` 중에서 선택할 수 있습니다. timestep_post_act (`str`, *선택 사항*, 기본값 `None`) : timestep 임베딩에 사용할 두 번째 활성화 함수입니다. `silu`, `mish`, `gelu` 중 하나를 선택할 수 있습니다. time_cond_proj_dim (`int`, *선택 사항*, 기본값 `None`) : timestep 임베딩의 `cond_proj` 레이어 차원입니다. conv_in_kernel (`int`, *선택 사항*, 기본값 `3`) : `conv_in` 레이어의 커널 크기. conv_out_kernel (`int`, *선택 사항*, 기본값 `3`) : `conv_out` 레이어의 커널 크기. projection_class_embeddings_input_dim (`int`, *선택 사항*) : `class_embed_type="projection"`일 때 `class_labels` 입력의 차원입니다. `class_embed_type="projection"`일 때 필수입니다. class_embeddings_concat (`bool`, *선택 사항*, 기본값 `False`) : 시간 임베딩을 클래스 임베딩과 연결할지 여부. 노이즈 샘플, 조건 상태, 타임스텝을 입력으로 받아 샘플 모양의 출력을 반환하는 조건부 2D UNet 모델입니다. 기본 [UNet2DConditionModel](/docs/diffusers/main/ko/api/models/unet2d-cond#diffusers.UNet2DConditionModel)과 비교할 때, 이 변형은 각 Transformer 블록에 추가적인 self-attention 레이어를 선택적으로 포함하고, 여러 cross-attention 레이어를 지원합니다. 또한 최대 두 개의 cross-attention 임베딩, `encoder_hidden_states`와 `encoder_hidden_states_1`를 허용합니다. 이 모델은 [ModelMixin](/docs/diffusers/main/ko/api/models/overview#diffusers.ModelMixin)에서 상속됩니다. 모든 모델에 대해 구현된 일반적 메서드(다운로드 또는 저장 등)에 대해서는 상위 클래스 문서를 확인하세요. #### 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) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/modeling_audioldm2.py#L494) **매개변수:** sample (`torch.Tensor`) : 다음 형태 `(batch, channel, height, width)`를 가진 노이즈 입력 텐서. timestep (`torch.Tensor` 또는 `float` 또는 `int`) : 입력을 디노이즈할 타임스텝 수. encoder_hidden_states (`torch.Tensor`) : `(batch, sequence_length, feature_dim)` 모양의 인코더 히든 상태입니다. encoder_attention_mask (`torch.Tensor`) : `(batch, sequence_length)` 모양의 cross-attention mask가 `encoder_hidden_states`에 적용됩니다. `True`인 경우 mask가 유지되고, `False`인 경우 폐기됩니다. Mask는 bias로 변환되어 "discard" 토큰에 해당하는 attention score에 큰 음의 값을 더합니다. return_dict (`bool`, *선택 사항*, 기본값 `True`) : 일반 튜플 대신 [UNet2DConditionOutput](/docs/diffusers/main/ko/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput)을 반환할지 여부. cross_attention_kwargs (`dict`, *선택 사항*) : 지정된 경우 `AttnProcessor`에 전달되는 kwargs 사전입니다. encoder_hidden_states_1 (`torch.Tensor`, *선택 사항*) : `(batch, sequence_length_2, feature_dim_2)` 모양의 인코더 히든 스테이트 두 번째 세트입니다. `encoder_hidden_states`와 다른 임베딩 세트에 대해 모델을 조건부화하는 데 사용할 수 있습니다. encoder_attention_mask_1 (`torch.Tensor`, *선택 사항*) : `(batch, sequence_length_2)` 모양의 크로스 어텐션 마스크가 `encoder_hidden_states_1`에 적용됩니다. `True`인 경우 마스크가 유지되고, `False`인 경우 폐기됩니다. 마스크는 바이어스로 변환되어 "폐기" 토큰에 해당하는 어텐션 점수에 큰 음의 값을 더합니다. **반환값:** [UNet2DConditionOutput](/docs/diffusers/main/ko/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) 또는 `tuple` `return_dict`가 True이면 [UNet2DConditionOutput](/docs/diffusers/main/ko/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput)이 반환되고, 그렇지 않으면 첫 번째 요소가 샘플 텐서인 `tuple`이 반환됩니다. [AudioLDM2UNet2DConditionModel](/docs/diffusers/main/ko/api/pipelines/audioldm2#diffusers.AudioLDM2UNet2DConditionModel)의 forward 메서드입니다. ## AudioPipelineOutput[[diffusers.AudioPipelineOutput]] #### diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]] ```python diffusers.AudioPipelineOutput(audios: ndarray) ``` [소스](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L149) **매개변수:** audios (`np.ndarray`) : `(batch_size, num_channels, sample_rate)` 모양의 NumPy 배열로 구성된 노이즈 제거된 오디오 샘플 목록. 오디오 파이프라인의 출력 클래스입니다.