Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /ja /api /pipelines /audioldm2.md
mishig
1 day ago
preview code
download
raw
45.4 kB
# 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](./stable_diffusion/overview)に着想を得たAudioLDM 2は、テキスト埋め込みから連続的な音声表現を学習する、テキストから音声を生成する_潜在拡散モデル（LDM）_です。プロンプト入力からテキスト埋め込みを計算するために、2つのテキストエンコーダーモデルが使用されます。具体的には、[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](./audioldm2#diffusers.AudioLDM2ProjectionModel)によって共有埋め込み空間に射影されます。次に、[GPT2](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2)の_言語モデル（LM）_が使用され、射影されたCLAPとFlan-T5の埋め込みを条件として、8つの新しい埋め込みベクトルを自己回帰的に予測します。生成された埋め込みベクトルとFlan-T5のテキスト埋め込みは、LDMにおけるクロスアテンションの条件付けとして使用されます。AudioLDM 2の[UNet](./audioldm2#diffusers.AudioLDM2UNet2DConditionModel)は、他の多くのLDMが1つのクロスアテンション条件付けを使用するのに対し、**2つ**のクロスアテンション埋め込みを受け取る点で独自性を持っています。

本論文の抄録は以下の通りです。

*音声生成は、音声、音楽、効果音といった異なるタイプの音声間で共通点を持つものの、各タイプ向けのモデルを設計する際には、他のタイプとは大きく異なる可能性のある特定の目的やバイアスに注意深く配慮する必要があります。音声生成の統合的な視点に近づけるために、本論文では、音声、音楽、効果音の生成に同じ学習手法を利用するフレームワークを提案します。本フレームワークでは、AudioMAE（自己教師あり事前学習された表現学習モデル）に基づいて、任意の音声を「language of audio」（LOA）と呼ばれる一般的な音声表現に変換します。生成プロセスでは、GPT-2モデルを用いて任意のモーダルをLOAに変換し、LOAを条件とする潜在拡散モデルで自己教師あり音声生成学習を行います。提案するフレームワークは、インコンテキスト学習能力や、再利用可能な自己教師あり事前学習済みAudioMAEおよび潜在拡散モデルといった利点を自然に持ちます。テキストから音声、テキストから音楽、テキストから音声合成への主要なベンチマークにおける実験により、従来の手法に対して最先端または競争力のある性能が示されました。コード、事前学習済みモデル、デモは[この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には3つのバリアントがあります。このうち2つのチェックポイントは、テキストからオーディオを生成する一般的なタスクに適用できます。3つ目のチェックポイントは、テキストから音楽を生成するタスクにのみ特化して学習されています。

すべてのチェックポイントは、テキストエンコーダーとVAEのモデルサイズが同一です。違いはUNetのサイズと深さにあります。3つのチェックポイントの詳細については、以下の表を参照してください。

| チェックポイント                                                      | タスク          | 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 のような一般的な用語を使用するのが望ましく、モデルが認識していない可能性がある固有名詞や抽象的なオブジェクトは避けてください。
* **ネガティブプロンプト**を使用すると、低品質な音声に対応する用語から生成を遠ざけることで、生成される波形の品質を大幅に向上させることができます。「Low quality.」をネガティブプロンプトとして使用してみてください。

### 推論の制御

* 予測されたオーディオサンプルの_品質_は、`num_inference_steps`引数によって制御できます。ステップ数を増やすと品質の高いオーディオが得られますが、推論速度は低下します。
* 予測された音声サンプルの_長さ_は、`audio_length_in_s`引数の値を変更することで制御できます。

### 生成された波形の評価:

* 生成された波形の品質は、シードによって大きく変動する可能性があります。満足できる生成結果が得られるまで、異なるシードで生成を試みてください。
* 一度に複数の波形を生成できます。`num_waveforms_per_prompt`を1より大きい値に設定してください。生成された波形とプロンプトテキストの間の自動スコアリングが実行され、オーディオが最良から最悪の順にランク付けされます。

上記のヒントを用いて、優れた音楽および音声の生成を行う方法を示す例を以下に示します: [example](./audioldm2#diffusers.AudioLDM2Pipeline.__call__.example)。

> [!TIP]
> スケジューラーのトレードオフ、すなわち速度と品質のバランスをどのように探求するかを学ぶには、[ガイド](../../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/ja/api/models/autoencoderkl#diffusers.AutoencoderKL)) : 画像を潜在表現にエンコードし、潜在表現からデコードするための変分オートエンコーダ（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`]) : 2番目の凍結されたテキストエンコーダー。AudioLDM2 は [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel) のエンコーダー、具体的には [google/flan-t5-large](https://huggingface.co/google/flan-t5-large) バリアントを使用します。TTS に使用される2番目の凍結されたテキストエンコーダー。AudioLDM2 は [Vits](https://huggingface.co/docs/transformers/model_doc/vits#transformers.VitsModel) のエンコーダーを使用します。
projection_model ([AudioLDM2ProjectionModel](/docs/diffusers/main/ja/api/pipelines/audioldm2#diffusers.AudioLDM2ProjectionModel)) : 第1および第2のテキストエンコーダーモデルからのhidden-statesを線形に射影し、学習されたSOSおよびEOSトークンの埋め込みを挿入するために使用される訓練済みモデルです。2つのテキストエンコーダーからの射影されたhidden-statesが連結され、言語モデルへの入力となります。Vitsのhidden-states用の学習済み位置埋め込み

language_model ([GPT2Model](https://huggingface.co/docs/transformers/main/en/model_doc/gpt2#transformers.GPT2Model)) : 2つのテキストエンコーダーからの射影出力を条件として、隠れ状態のシーケンスを生成するために使用される自己回帰型言語モデル。
tokenizer ([RobertaTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/led#transformers.RobertaTokenizer)) : 最初の凍結されたテキストエンコーダー用のテキストをトークン化するトークナイザー。
tokenizer_2 ([`~transformers.T5Tokenizer`, `~transformers.VitsTokenizer`]) : 2番目の凍結されたテキストエンコーダー用のテキストをトークン化するためのトークナイザー。

feature_extractor ([ClapFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/clap#transformers.ClapFeatureExtractor)) : 自動スコアリングのために、生成されたオーディオ波形をログメルスペクトログラムへ前処理するフィーチャーエクストラクター。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : エンコードされたオーディオの潜在変数をノイズ除去するための `UNet2DConditionModel`。
scheduler ([SchedulerMixin](/docs/diffusers/main/ja/api/schedulers/overview#diffusers.SchedulerMixin)) : `unet` と組み合わせて、エンコードされたオーディオの潜在変数をデノイズするために使用するスケジューラ。[DDIMScheduler](/docs/diffusers/main/ja/api/schedulers/ddim#diffusers.DDIMScheduler)、[LMSDiscreteScheduler](/docs/diffusers/main/ja/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler)、または [PNDMScheduler](/docs/diffusers/main/ja/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/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。すべてのパイプラインに実装されている汎用的なメソッド（ダウンロード、保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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')
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/audioldm2/pipeline_audioldm2.py#L844)
**パラメータ:**
prompt (`str` または `list[str]`、*省略可能*) : 音声生成をガイドするためのプロンプトです。未定義の場合、`prompt_embeds` を渡す必要があります。

transcription (`str` または `list[str]`、*省略可*) -- テキスト読み上げ用のトランスクリプト。

audio_length_in_s (`int`、*optional*、デフォルトは 10.24) : 生成されるオーディオサンプルの長さ（秒）。
num_inference_steps (`int`、*optional*、デフォルトは 200) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常、より高品質なオーディオが得られます。
guidance_scale (`float`、*任意*、デフォルト値は 3.5) : guidance scale の値を高くすると、`prompt` のテキストと密接に関連するオーディオを生成するようモデルに促されますが、その代わりとして音質が低下します。`guidance_scale > 1` の場合、guidance scale が有効になります。

negative_prompt (`str` または `list[str]`、*省略可*) : 音声生成において含めるべきでない内容を指示するためのプロンプトです。未定義の場合、代わりに `negative_prompt_embeds` を渡す必要があります。guidance を使用していない場合（`guidance_scale < 1`）は無視されます。

num_waveforms_per_prompt (`int`、*optional*、デフォルトは 1) : プロンプトごとに生成する波形の数を指定します。`num_waveforms_per_prompt > 1` の場合、生成された出力とテキストプロンプトの間に自動スコアリングが実行されます。このスコアリングは、テキストとオーディオの結合埋め込み空間におけるテキスト入力とのコサイン類似度に基づいて、生成された波形をランキング付けします。

eta (`float`、*任意*、デフォルト値は 0.0) : [DDIM](https://huggingface.co/papers/2010.02502)論文のパラメータ eta (η) に対応します。[DDIMScheduler](/docs/diffusers/main/ja/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`, *任意*) : ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。スペクトログラム生成の入力として使用します。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダム `generator` を用いてサンプリングを行い、ラテンツが生成されます。

prompt_embeds (`torch.Tensor`, *任意*) : 事前に生成されたテキスト埋め込み。テキスト入力（プロンプトの重み付け）を簡単に調整するために使用できます。指定されない場合、`prompt` 入力引数からテキスト埋め込みが生成されます。
negative_prompt_embeds (`torch.Tensor`, *任意*) : 事前に生成されたネガティブなテキスト埋め込み。テキスト入力（プロンプトの重み付け）を簡単に調整するために使用できます。指定されない場合、`negative_prompt_embeds` は `negative_prompt` 入力引数から生成されます。

generated_prompt_embeds (`torch.Tensor`, *任意*) : GPT2言語モデルから生成された事前テキスト埋め込み。プロンプトの重み付けなど、*例えば*テキスト入力の調整を簡単に実行できます。指定されない場合、`prompt`入力引数からテキスト埋め込みが生成されます。

negative_generated_prompt_embeds (`torch.Tensor`, *任意*) : GPT2言語モデルから事前生成されたネガティブテキスト埋め込み。テキスト入力の調整、*例えば*プロンプトの重み付けなどを簡単に実行できます。指定されない場合、`negative_prompt`入力引数からnegative_prompt_embedsが計算されます。

attention_mask (`torch.LongTensor`, *任意*) : `prompt_embeds` に適用する事前計算済みのアテンションマスクです。指定しない場合、`prompt` 入力引数からアテンションマスクが計算されます。

negative_attention_mask (`torch.LongTensor`, *任意*) : `negative_prompt_embeds` に適用する事前計算済みのアテンションマスクです。指定しない場合、`negative_prompt` 入力引数からアテンションマスクが計算されます。

max_new_tokens (`int`、*任意*、デフォルトは None) : GPT2 言語モデルで生成する新しいトークンの数。指定しない場合、モデルの config からトークン数が取得されます。

return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[StableDiffusionPipelineOutput](/docs/diffusers/main/ja/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`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、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"`) : 生成されたオーディオの出力形式です。`"np"` を指定すると NumPy の `np.ndarray` を返し、`"pt"` を指定すると PyTorch の `torch.Tensor` オブジェクトを返します。`"latent"` を設定すると、潜在拡散モデル (LDM) の出力を返します。

**戻り値:** [StableDiffusionPipelineOutput](/docs/diffusers/main/ja/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) または `tuple`

`return_dict` が `True` の場合、[StableDiffusionPipelineOutput](/docs/diffusers/main/ja/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` メソッドが呼び出されたときに、一度に 1 つのモデル全体を 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#L331)

**パラメータ:**

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`, *任意*) : GPT2言語モデルから生成された事前テキスト埋め込み。プロンプトの重み付けなど、*例えば*テキスト入力の調整を簡単に実行できます。指定されない場合、`prompt`入力引数からテキスト埋め込みが生成されます。

negative_generated_prompt_embeds (`torch.Tensor`, *任意*) : GPT2言語モデルから事前生成されたネガティブテキスト埋め込み。テキスト入力の調整、*例えば*プロンプトの重み付けなどを簡単に実行できます。指定されない場合、`negative_prompt`入力引数からnegative_prompt_embedsが計算されます。

attention_mask (`torch.LongTensor`, *任意*) : `prompt_embeds` に適用する事前計算済みのアテンションマスクです。指定しない場合、`prompt` 入力引数からアテンションマスクが計算されます。

negative_attention_mask (`torch.LongTensor`, *任意*) : `negative_prompt_embeds` に適用する事前計算済みのアテンションマスクです。指定しない場合、`negative_prompt` 入力引数からアテンションマスクが計算されます。

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#L278)

**パラメータ:**

inputs_embeds (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : 生成のプロンプトとして使用されるシーケンス。

max_new_tokens (`int`) : 生成する新しいトークンの数。

model_kwargs (`dict[str, Any]`、*任意*) : モデル固有の追加の kwargs をアドホックにパラメータ化し、モデルの `forward` 関数に転送します。
**戻り値:** `inputs_embeds (`torch.Tensor` of shape `(batch_size, sequence_length, hidden_size)`)

生成された 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`) : 2番目のテキストエンコーダー（T5またはVITS）からのテキスト埋め込みの次元数。
langauge_model_dim (`int`) : 言語モデル（GPT2）からのテキスト埋め込みの次元数。
2つのテキスト埋め込みを共有潜在空間にマッピングするための、シンプルな線形投影モデルです。また、各テキスト埋め込みシーケンスの先頭と末尾に、それぞれ学習された埋め込みベクトルを挿入します。`_1` が付加された各変数は、2番目のテキストエンコーダーに対応するものです。それ以外は、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)`、*optional*) : 最初のテキストエンコーダー (CLAP) からのテキスト埋め込み。
hidden_states_1 (`torch.Tensor`、shape `(batch_size, sequence_length_1, text_encoder_1_dim)`、*任意*) : 2番目のテキストエンコーダー（T5またはVITS）からのテキスト埋め込み。
attention_mask (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : `hidden_states` 用のアテンションマスク。

attention_mask_1 (`torch.LongTensor`、形状 `(batch_size, sequence_length_1)`、*任意*) : `hidden_states_1` 用のアテンションマスク。

**戻り値:** `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[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)
```

[ソース](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`、*optional*、デフォルトは 0) : 時間埋め込みに適用する周波数シフト。
down_block_types (`tuple[str]`、*任意*、デフォルトは`("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : 使用するダウンサンプルブロックのタプルです。
mid_block_type (`str`、*任意*、デフォルトは `"UNetMidBlock2DCrossAttn"`) : UNet の中央部分のブロックタイプです。AudioLDM2 の場合は `UNetMidBlock2DCrossAttn` のみ指定できます。
up_block_types (`tuple[str]`、*optional*、デフォルトは`("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : 使用するアップサンプルブロックのタプル。
only_cross_attention (`bool` または `tuple[bool]`、*省略可能*、デフォルトは `False`) : 基本的な Transformer ブロックに自己注意機構を含めるかどうかを指定します。`BasicTransformerBlock` を参照してください。
block_out_channels (`tuple[int]`、*optional*、デフォルトは`(320, 640, 1280, 1280)`) : 各ブロックの出力チャネル数を表すタプルです。
layers_per_block (`int`、*任意*、デフォルトは 2) : ブロックあたりのレイヤー数。
downsample_padding (`int`、*optional*、デフォルトは 1) : ダウンサンプリング畳み込みに使用するパディング。

mid_block_scale_factor (`float`、*任意*、デフォルトは 1.0) : mid block に使用するスケール係数。
act_fn (`str`、*任意*、デフォルトは`"silu"`) : 使用する活性化関数。

norm_num_groups (`int`、*optional*、デフォルトは 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`) : タイムステップに使用する位置埋め込みの種類。`positional`または`fourier`から選択します。

time_embedding_dim (`int`、*任意*、デフォルトは`None`) : 投影された時間埋め込みの次元をオーバーライドするための任意の引数です。

time_embedding_act_fn (`str`、*任意*、デフォルトは`None`) : UNetの残りの部分に渡す前に、時間埋め込みに一度だけ適用する任意の活性化関数。`silu`、`mish`、`gelu`、`swish`から選択できます。
timestep_post_act (`str`、*任意*、デフォルトは `None`) : タイムステップ埋め込みで使用する第2の活性化関数。`silu`、`mish`、`gelu` から選択してください。
time_cond_proj_dim (`int`、*任意*、デフォルトは`None`) : 時間ステップ埋め込みにおける`cond_proj`レイヤーの次元数。

conv_in_kernel (`int`、*optional*、デフォルトは`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/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)と比較して、このバリアントでは、各Transformerブロックに追加の自己注意層を任意に含めることができ、また複数のクロス注意層も備えています。さらに、最大2つのクロス注意埋め込み、`encoder_hidden_states`と`encoder_hidden_states_1`を許可します。

このモデルは [ModelMixin](/docs/diffusers/main/ja/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`) : `encoder_hidden_states` に、`(batch, sequence_length)` の形状を持つクロスアテンションマスクが適用されます。`True` の場合はマスクが保持され、`False` の場合は破棄されます。マスクはバイアスに変換され、「破棄」対象のトークンに対応するアテンションスコアに大きな負の値が加算されます。

return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[UNet2DConditionOutput](/docs/diffusers/main/ja/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)` の、第2のエンコーダーの隠れ状態のセットです。`encoder_hidden_states` とは異なる埋め込みのセットでモデルを条件付けするために使用できます。

encoder_attention_mask_1 (`torch.Tensor`, *任意*) : 形状が `(batch, sequence_length_2)` のクロスアテンションマスクが `encoder_hidden_states_1` に適用されます。`True` の場合はマスクが保持され、`False` の場合は破棄されます。マスクはバイアスに変換され、「破棄」対象のトークンに対応するアテンションスコアに大きな負の値が加算されます。

**戻り値:** [UNet2DConditionOutput](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) または `tuple`

`return_dict` が True の場合、[UNet2DConditionOutput](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) が返され、それ以外の場合は、最初の要素がサンプルテンソルである `tuple` が返されます。

[AudioLDM2UNet2DConditionModel](/docs/diffusers/main/ja/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 配列のデノイズ済みオーディオサンプルのリスト。

音声パイプライン用の出力クラス。
Xet Storage Details

Size:: 45.4 kB
Xet hash:: 4514269dadd52ceda0d3a12bb089799266f1884746e7f7d90b604355c66f2edd
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.