Buckets:

mishig's picture
|
download
raw
42.3 kB

AudioLDM 2

AudioLDM 2는 Haohe Liu 외의 연구자들이 AudioLDM 2: Learning Holistic Audio Generation with Self-supervised Pretraining에서 제안했습니다. AudioLDM 2는 텍스트 프롬프트를 입력으로 받아 이에 해당하는 오디오를 예측합니다. 텍스트 조건부 효과음, 인간 음성, 음악을 생성할 수 있습니다.

Stable Diffusion에서 영감을 받은 AudioLDM 2는 텍스트 임베딩에서 연속적인 오디오 표현을 학습하는 텍스트-오디오 _latent diffusion model (LDM)_입니다. 프롬프트 입력으로부터 텍스트 임베딩을 계산하기 위해 두 가지 텍스트 인코더 모델이 사용됩니다: CLAP의 텍스트 브랜치와 Flan-T5의 인코더입니다. 이러한 텍스트 임베딩은 AudioLDM2ProjectionModel에 의해 공유 임베딩 공간으로 투영됩니다. GPT2 _language model (LM)_은 투영된 CLAP 및 Flan-T5 임베딩을 조건으로 하여 8개의 새로운 임베딩 벡터를 자기회귀적으로 예측하는 데 사용됩니다. 생성된 임베딩 벡터와 Flan-T5 텍스트 임베딩은 LDM에서 크로스 어텐션 조건으로 사용됩니다. AudioLDM 2의 UNet은 대부분의 다른 LDM이 하나의 크로스 어텐션 조건을 사용하는 것과 달리, 두 개의 크로스 어텐션 임베딩을 입력으로 받는다는 점에서 독특합니다.

해당 논문의 초록은 다음과 같습니다:

음성, 음악, 효과음 등 다양한 유형의 오디오는 공통점을 공유하지만, 각 유형에 대한 모델 설계는 서로 크게 다를 수 있는 특정 목표와 편향을 신중하게 고려해야 합니다. 오디오 생성에 대한 통합된 관점을 한층 더 가까이 가져가기 위해, 이 논문은 음성, 음악, 효과음 생성에 동일한 학습 방법을 활용하는 프레임워크를 제안합니다. 제안된 프레임워크는 "오디오의 언어"(LOA)라고 불리는 오디오의 일반적 표현을 도입합니다. AudioMAE라는 자기지도 사전학습 표현 학습 모델을 기반으로, 모든 오디오를 LOA로 변환할 수 있습니다. 생성 과정에서 GPT-2 모델을 사용하여 모든 모달리티를 LOA로 변환하고, LOA를 조건으로 하는 잠재 확산 모델(latent diffusion model)로 자기지도 오디오 생성 학습을 수행합니다. 제안된 프레임워크는 컨텍스트 학습 능력과 재사용 가능한 자기지도 사전학습 AudioMAE 및 잠재 확산 모델과 같은 이점을 자연스럽게 제공합니다. 텍스트-오디오, 텍스트-음악, 텍스트-음성 생성의 주요 벤치마크에 대한 실험은 이전 접근 방식에 비해 최첨단 또는 경쟁력 있는 성능을 입증합니다. 코드, 사전학습 모델, 데모는 이 https URL에서 사용할 수 있습니다.

이 파이프라인은 sanchit-gandhi와 Nguyễn Công Tú Anh가 기여했습니다. 원본 코드베이스는 haoheliu/audioldm2에서 찾을 수 있습니다.

팁

체크포인트 선택

AudioLDM2에는 세 가지 변형이 있습니다. 이 중 두 개의 체크포인트는 텍스트-오디오 생성이라는 일반적인 작업에 적용됩니다. 세 번째 체크포인트는 텍스트-음악 생성에만 학습되었습니다.

모든 체크포인트는 텍스트 인코더와 VAE의 모델 크기가 동일합니다. UNet의 크기와 깊이가 서로 다릅니다. 세 가지 체크포인트에 대한 세부 사항은 아래 표를 참조하세요:

체크포인트 작업 UNet 모델 크기 모델 전체 크기 학습 데이터 / h
audioldm2 텍스트-오디오 350M 1.1B 1150k
audioldm2-large 텍스트-오디오 750M 1.5B 1150k
audioldm2-music 텍스트-투-음악 350M 1.1B 665k
audioldm2-gigaspeech 텍스트-음성 350M 1.1B 10k
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 팁을 활용하여 좋은 음악 및 음성 생성을 구성하는 방법을 보여줍니다: 예제.

Scheduler의 가이드를 확인하여 스케줄러의 속도와 품질 사이의 트레이드오프를 탐색하는 방법을 배우고, 파이프라인 간 구성 요소 재사용 섹션을 확인하여 동일한 구성 요소를 여러 파이프라인에 효율적으로 로드하는 방법을 배워보세요.

AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

diffusers.AudioLDM2Pipeline[[diffusers.AudioLDM2Pipeline]]

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)

소스

매개변수:

vae (AutoencoderKL) : 이미지를 잠재 표현으로 인코딩하고 잠재 표현에서 이미지로 디코딩하는 Variational Auto-Encoder (VAE) 모델입니다.

text_encoder (ClapModel) : 첫 번째 고정된 텍스트 인코더입니다. AudioLDM2는 오디오-텍스트 결합 임베딩 모델인 CLAP, 구체적으로 laion/clap-htsat-unfused 변형을 사용합니다. 텍스트 브랜치는 텍스트 프롬프트를 프롬프트 임베딩으로 인코딩하는 데 사용됩니다. 전체 오디오-텍스트 모델은 유사도 점수를 계산하여 생성된 웨이브폼을 텍스트 프롬프트와 비교하여 순위를 매기는 데 사용됩니다.

text_encoder_2 ([~transformers.T5EncoderModel, ~transformers.VitsModel]) : 두 번째 고정된 텍스트 인코더. AudioLDM2는 T5 인코더, 구체적으로 google/flan-t5-large 변형을 사용합니다. TTS에 사용되는 두 번째 고정된 텍스트 인코더입니다. AudioLDM2는 Vits 인코더를 사용합니다.

projection_model (AudioLDM2ProjectionModel) : 첫 번째 및 두 번째 텍스트 인코더 모델의 hidden-states를 선형적으로 투사하고 학습된 SOS 및 EOS 토큰 임베딩을 삽입하는 데 사용되는 학습된 모델입니다. 두 텍스트 인코더에서 투사된 hidden-states가 연결되어 언어 모델의 입력을 형성합니다. Vits hidden-states에 대한 학습된 위치 임베딩

language_model (GPT2Model) : 두 텍스트 인코더의 투영된 출력을 조건으로 하여 hidden-states 시퀀스를 생성하는 자동 회귀 언어 모델입니다.

tokenizer (RobertaTokenizer) : 첫 번째 동결된 텍스트 인코더에 사용할 텍스트를 토큰화하는 토크나이저입니다.

tokenizer_2 ([~transformers.T5Tokenizer, ~transformers.VitsTokenizer]) : 두 번째 고정된 text-encoder에 사용할 텍스트를 토큰화하는 Tokenizer.

feature_extractor (ClapFeatureExtractor) : 자동 점수를 위해 생성된 오디오 웨이브폼을 로그-멜 스펙트로그램으로 전처리하는 피처 추출기.

unet (UNet2DConditionModel) : 인코딩된 오디오 라텐트를 디노이즈하기 위한 UNet2DConditionModel.

scheduler (SchedulerMixin) : unet와 함께 사용되어 인코딩된 오디오 잠재를 디노이즈하는 스케줄러입니다. DDIMScheduler, LMSDiscreteScheduler, 또는 PNDMScheduler 중 하나일 수 있습니다.

vocoder (SpeechT5HifiGan) : 멜 스펙트로그램 잠재를 최종 오디오 웨이브폼으로 변환하는 SpeechT5HifiGan 클래스의 보코더.

AudioLDM2를 사용한 텍스트-오디오 생성을 위한 Pipeline

이 모델은 DiffusionPipeline에서 상속됩니다. 모든 파이프라인에 대해 구현된 일반적 메서드(다운로드, 저장, 특정 디바이스에서 실행 등)에 대해서는 상위 클래스 문서를 확인하세요.

호출[[diffusers.AudioLDM2Pipeline.call]]

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

소스

매개변수:

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 논문에서 정의한 파라미터 eta (η)에 해당합니다. DDIMScheduler에만 적용되며, 다른 스케줄러에서는 무시됩니다.

generator (torch.Generator 또는 list[torch.Generator], 선택 사항) : 생성을 결정적으로 만들기 위한 torch.Generator입니다.

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을 반환할지 여부.

callback (Callable, 선택 사항) : 추론 중 callback_steps 단계마다 호출되는 함수입니다. 이 함수는 다음 인수를 받아 호출됩니다: callback(step: int, timestep: int, latents: torch.Tensor).

callback_steps (int, 선택 사항, 기본값 1) : callback 함수가 호출되는 주기입니다. 지정하지 않으면 모든 단계에서 콜백이 호출됩니다.

cross_attention_kwargs (dict, 선택 사항) : 지정된 경우 self.processor에서 정의된 AttentionProcessor로 전달되는 kwargs 사전입니다.

output_type (str, 선택 사항, 기본값 "np") : 생성된 오디오의 출력 형식입니다. NumPy np.ndarray를 반환하려면 "np"를, PyTorch torch.Tensor 객체를 반환하려면 "pt"를 선택합니다. latent diffusion model (LDM) 출력을 반환하려면 "latent"로 설정합니다.

반환값: StableDiffusionPipelineOutput 또는 tuple

return_dict가 True인 경우 StableDiffusionPipelineOutput가 반환되고, 그렇지 않으면 생성된 오디오를 포함하는 리스트가 첫 번째 요소인 tuple이 반환됩니다.

생성을 위한 pipeline의 호출 함수.

예:

>>> 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]]

enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = 'cuda')

소스

accelerate를 사용하여 모든 모델을 CPU로 오프로드하여 성능에 미치는 영향은 적으면서 메모리 사용량을 줄입니다. enable_sequential_cpu_offload와 비교하면, 이 메서드는 forward 메서드가 호출될 때 한 번에 하나의 모델을 GPU로 이동하며, 다음 모델이 실행될 때까지 해당 모델은 GPU에 유지됩니다. enable_sequential_cpu_offload를 사용할 때보다 메모리 절감 효과는 낮지만, unet의 반복적 실행 덕분에 성능이 훨씬 좋습니다.

encode_prompt[[diffusers.AudioLDM2Pipeline.encode_prompt]]

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)

소스

매개변수:

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 언어 모델에서 생성된 텍스트 임베딩.

프롬프트를 텍스트 인코더의 히든 상태로 인코딩합니다.

예:

>>> 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]]

generate_language_model(inputs_embeds: Tensor = None, max_new_tokens: int = 8, **model_kwargs)

소스

매개변수:

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.Tensorof shape(batch_size, sequence_length, hidden_size)`)

생성된 hidden-states의 시퀀스.

임베딩 입력을 조건으로 삼아 언어 모델에서 hidden-states 시퀀스를 생성합니다.

AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]]

diffusers.AudioLDM2ProjectionModel[[diffusers.AudioLDM2ProjectionModel]]

diffusers.AudioLDM2ProjectionModel(text_encoder_dim, text_encoder_1_dim, langauge_model_dim, use_learned_position_embedding = None, max_seq_length = None)

소스

매개변수:

text_encoder_dim (int) : 첫 번째 텍스트 인코더(CLAP)에서 생성된 텍스트 임베딩의 차원

text_encoder_1_dim (int) : 두 번째 텍스트 인코더(T5 또는 VITS)에서 생성된 텍스트 임베딩의 차원.

langauge_model_dim (int) : 언어 모델(GPT2)의 텍스트 임베딩 차원

두 텍스트 임베딩을 공유된 잠재 공간으로 매핑하는 단순한 선형 투영 모델입니다. 또한 각 텍스트 임베딩 시퀀스의 시작과 끝에 학습된 임베딩 벡터를 각각 삽입합니다. _1로 끝나는 각 변수는 두 번째 텍스트 인코더에 해당하는 것을 나타냅니다. 그렇지 않은 경우, 해당 변수는 첫 번째 텍스트 인코더에서 가져온 것입니다.

forward[[diffusers.AudioLDM2ProjectionModel.forward]]

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)

소스

매개변수:

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]]

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)

소스

매개변수:

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과 비교할 때, 이 변형은 각 Transformer 블록에 추가적인 self-attention 레이어를 선택적으로 포함하고, 여러 cross-attention 레이어를 지원합니다. 또한 최대 두 개의 cross-attention 임베딩, encoder_hidden_states와 encoder_hidden_states_1를 허용합니다.

이 모델은 ModelMixin에서 상속됩니다. 모든 모델에 대해 구현된 일반적 메서드(다운로드 또는 저장 등)에 대해서는 상위 클래스 문서를 확인하세요.

forward[[diffusers.AudioLDM2UNet2DConditionModel.forward]]

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)

소스

매개변수:

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을 반환할지 여부.

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 또는 tuple

return_dict가 True이면 UNet2DConditionOutput이 반환되고, 그렇지 않으면 첫 번째 요소가 샘플 텐서인 tuple이 반환됩니다.

AudioLDM2UNet2DConditionModel의 forward 메서드입니다.

AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput[[diffusers.AudioPipelineOutput]]

diffusers.AudioPipelineOutput(audios: ndarray)

소스

매개변수:

audios (np.ndarray) : (batch_size, num_channels, sample_rate) 모양의 NumPy 배열로 구성된 노이즈 제거된 오디오 샘플 목록.

오디오 파이프라인의 출력 클래스입니다.

Xet Storage Details

Size:
42.3 kB
·
Xet hash:
87a7fb72e1183b06576a2aec0bd062b42f5e9921210b277cac715de7e1de23ab

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.