# CLVP

## 概要

CLVP（Contrastive Language-Voice Pretrained Transformer）モデルは、James Betker 氏による論文 [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) で提案されました。

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

*近年、自己回帰型TransformerやDDPMの応用により、画像生成の分野は大きく変革されました。これらのアプローチは、画像生成のプロセスを段階的な確率過程としてモデル化し、大量の計算リソースとデータを活用して画像分布を学習します。このパフォーマンス向上の手法は、画像に限定される必要はありません。本論文では、画像生成分野での進歩を音声合成に応用する方法を説明します。その結果として生まれたのが、表現力豊かで複数ボイスに対応するテキストトゥスピーチシステムTorToiseです。*

このモデルは [Susnato Dhar](https://huggingface.co/susnato) によって提供されました。元のコードは [こちら](https://github.com/neonbjb/tortoise-tts) で確認できます。

## 使用のコツ

1. CLVPはTortoise TTSモデルの不可欠な一部です。
2. CLVPは、提供されたテキストと異なる生成音声候補を比較するために使用でき、最適な音声トークンは拡散モデルに転送されます。
3. tortoise の使用には、`ClvpModelForConditionalGeneration.generate()` メソッドの利用を強く推奨します。
4. CLVPモデルは、16 kHzを想定する他の音声モデルとは異なり、22.05 kHzでサンプリングされた音声を想定している点にご注意ください。

## 簡単な説明

- [ClvpTokenizer](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpTokenizer) はテキスト入力をトークン化し、[ClvpFeatureExtractor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor) は対象の音声からログメルスペクトログラムを抽出します。
- `ClvpConditioningEncoder` は、これらのテキストトークンと音声表現を受け取り、テキストと音声中の条件付きエンベディングに変換します。
- [ClvpForCausalLM](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpForCausalLM) は、これらの埋め込みを使用して複数の音声候補を生成します。
- 各音声候補は音声エンコーダー([ClvpEncoder](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpEncoder))に渡され、ベクトル表現に変換されます。また、テキストエンコーダー([ClvpEncoder](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpEncoder))は、テキストトークンを同じ潜在空間に変換します。
- 最後に、各音声ベクトルをテキストベクトルと比較し、テキストベクトルに最も類似した音声ベクトルを特定します。
- `ClvpModelForConditionalGeneration.generate()` は、上記で説明したすべてのロジックを単一のメソッドに集約しています。

例:

```python
import datasets

from transformers import ClvpModelForConditionalGeneration, ClvpProcessor

# Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
text = "This is an example text."

ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
sample = ds[0]["audio"]

# Define processor and model.
processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev", device_map="auto")

# Generate processor output and model output.
processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt").to(model.device)
generated_output = model.generate(**processor_output)
```

## ClvpConfig[[transformers.ClvpConfig]]

#### transformers.ClvpConfig[[transformers.ClvpConfig]]

```python
transformers.ClvpConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, speech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 768, logit_scale_init_value: float = 2.6592, initializer_factor: float = 1.0)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L185)

**パラメータ:**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *任意*) : テキストバックボーンの config オブジェクトまたは辞書。

speech_config (`dict`, *任意*) : CLVP音声エンコーダーの初期化に使用される設定オプションの辞書。

decoder_config (`dict`, *省略可*) : [ClvpDecoderConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpDecoderConfig) を初期化するために使用される設定オプションの辞書。

projection_dim (`int`、*任意*、デフォルトは`768`) : テキストおよびビジョンの投影層の次元数。

logit_scale_init_value (`float`、*任意*、デフォルトは `2.6592`) : *logit_scale* パラメータの初期値です。

initializer_factor (`float`、*任意*、デフォルトは`1.0`) : すべての重み行列を初期化する係数です（1に保つ必要があります。初期化テスト用に内部で使用されます）。

これは、[susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) と同様の設定をデフォルト値で生成する、ClvpModelForConditionalGeneration の設定を保存するための設定クラスです。指定された引数に基づいて Clvp モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> from transformers import ClvpConfig, ClvpModelForConditionalGeneration

>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()

>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig

>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()

>>> config = ClvpConfig(config_text, config_speech, decoder_config)
```

## ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

#### transformers.ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

```python
transformers.ClvpEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 256, hidden_size: int = 768, intermediate_size: int = 1536, projection_dim: int = 768, num_hidden_layers: int = 20, num_attention_heads: int = 12, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, use_rotary_embedding: bool = True, use_attention_bias: bool = False, summary_type: str = 'mean', initializer_factor: float = 1.0, bos_token_id: int | None = 255, eos_token_id: int | list[int] | None = 0, pad_token_id: int | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L29)

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは `256`) : モデルの語彙サイズ。`input_ids` で表現できるトークンの種類数を定義します。

hidden_size (`int`、*任意*、デフォルトは`768`) : 隠れ表現の次元数。

intermediate_size (`int`, *optional*, デフォルトは `1536`) : MLP 表現の次元数。

projection_dim (`int`、*任意*、デフォルトは`768`) : テキストおよびビジョンの投影層の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは`20`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは `12`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

hidden_act (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。

layer_norm_eps (`float`、*任意*、デフォルトは`1e-05`) : Layer Normalization 層で使用する epsilon。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : 注意確率のドロップアウト率。

dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

use_rotary_embedding (`bool`, *任意*, デフォルトは `True`) : rotary_embedding を使用するかどうかを指定します。

use_attention_bias (`bool`, *任意*, デフォルトは `False`) : セルフアテンションにおいて、Query、Key、Value 層にバイアスを使用するかどうか。

summary_type (`str`, *optional*, defaults to `"mean"`) : What strategy to use to get pooler_output from the last_hidden_state. `"last"`, `"first"`, `"mean"` and `"cls_index"` are supported.

initializer_factor (`float`、*任意*、デフォルトは`1.0`) : すべての重み行列を初期化する係数です（1に保つ必要があります。初期化テスト用に内部で使用されます）。

bos_token_id (`int`、*任意*、デフォルトは`255`) : 語彙内でストリームの開始に使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`0`) : 語彙内でストリーム終了に使用されるトークン ID。

pad_token_id (`int`, *任意*) : 語彙内でパディングに使用されるトークンID。

これは、[susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) と同様の設定をデフォルト値で生成する、ClvpModelForConditionalGeneration の設定を保存するための設定クラスです。指定された引数に基づいて Clvp モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> from transformers import ClvpEncoderConfig, ClvpEncoder

>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()

>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

#### transformers.ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

```python
transformers.ClvpDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 8194, max_position_embeddings: int = 608, max_text_tokens: int = 404, hidden_size: int = 1024, num_hidden_layers: int = 30, num_attention_heads: int = 16, n_inner: int | None = None, num_mel_attn_blocks: int = 6, activation_function: str = 'gelu_new', resid_pdrop: float | int = 0.1, embd_pdrop: float | int = 0.1, attention_dropout: float | int = 0.1, layer_norm_epsilon: float = 1e-05, initializer_range: float = 0.02, summary_type: str = 'cls_index', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, use_cache: bool = True, bos_token_id: int | None = 8192, eos_token_id: int | list[int] | None = 8193, pad_token_id: int | None = None, feature_size: int = 80, use_attention_bias: bool = True, initializer_factor: float = 1.0, decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248), add_cross_attention: bool = False)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L103)

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは`8194`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

max_position_embeddings (`int`、*任意*、デフォルトは`608`) : このモデルが使用される可能性のある最大シーケンス長です。

max_text_tokens (`int`、*optional*、デフォルトは 404) : このモデルが使用される場合に想定されるテキストトークンの最大シーケンス長です。`GPT2Config` の `n_positions` と同様のものです。

hidden_size (`int`、*任意*、デフォルトは`1024`) : 隠れ表現の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは`30`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは`16`) : Transformerデコーダーの各アテンション層におけるアテンションヘッドの数。

n_inner (`int`, *任意*) : 内部フィードフォワード層の次元数。 `None` の場合、 `hidden_size` の4倍に設定されます。

num_mel_attn_blocks (`int`、*optional*、デフォルトは 6) : `ClvpConditioningEncoder` における自己アテンション層の数を示します。

activation_function (`str`、*任意*、デフォルトは `gelu_new`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。

resid_pdrop (`Union[float, int]`、*任意*、デフォルト値は`0.1`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。

embd_pdrop (`Union[float, int]`、*任意*、デフォルトは `0.1`) : 埋め込みの dropout 率。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : 注意確率のドロップアウト率。

layer_norm_epsilon (`float`、*任意*、デフォルトは`1e-05`) : Layer Normalization 層で使用する epsilon。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

summary_type (`string`、*任意*、デフォルトは `"cls_index"`) : シーケンスサマリーを行う際に使用される引数。以下のオプションのいずれかである必要があります: - `"last"`: 最後のトークンの隠れ状態を取得します（XLNetと同様）。 - `"first"`: 最初のトークンの隠れ状態を取得します（BERTと同様）。 - `"mean"`: 全トークンの隠れ状態の平均を取得します。 - `"cls_index"`: 分類トークンの位置を示すTensorを指定します（GPT/GPT-2と同様）。 - `"attn"`: 現在未実装です。マルチヘッドアテンションを使用します。

summary_use_proj (`bool`、*任意*、デフォルトは`True`) : ベクトル抽出後に射影を追加するかどうか。

summary_activation (`str`, *任意*) : 出力に tanh 活性化を適用するには `"tanh"` を渡します。それ以外の値を渡すと、活性化は適用されません。

summary_proj_to_labels (`bool`、*任意*、デフォルトは`True`) : 投影の出力が`config.num_labels`クラスか`config.hidden_size`クラスを持つかを指定します。

summary_first_dropout (`float`, *optional*, デフォルトは 0.1) : 投影と活性化の後に使用される dropout の比率。

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

bos_token_id (`int`, *任意*, デフォルトは `8192`) : 語彙内でストリームの開始に使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`8193`) : 語彙内でストリーム終了に使用されるトークン ID。

pad_token_id (`int`, *任意*) : 語彙内でパディングに使用されるトークンID。

feature_size (`int`、*optional*、デフォルトは 80) : 抽出される mel 特徴量の次元数です。この値は `ClvpConditioningEncoder` で使用されます。

use_attention_bias (`bool`、*任意*、デフォルトは`True`) : セルフアテンションにおいて、Query、Key、Value層にバイアスを使用するかどうか。

initializer_factor (`float`、*任意*、デフォルトは`1.0`) : すべての重み行列を初期化する係数です（1に保つ必要があります。初期化テスト用に内部で使用されます）。

decoder_fixing_codes (`list`、*任意*、デフォルトは `[83, 45, 45, 248]`) : これらの値は、メソッド `fix_speech_decoder_output` 内で、デコーダーが生成した出力を修正するために使用されます。

add_cross_attention (`bool`、*任意*、デフォルトは`False`) : モデルにクロスアテンション層を追加するかどうか。

これは、[susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) と同様の設定をデフォルト値で生成する、ClvpModelForConditionalGeneration の設定を保存するための設定クラスです。指定された引数に基づいて Clvp モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> from transformers import ClvpDecoderConfig, ClvpDecoder

>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()

>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ClvpTokenizer[[transformers.ClvpTokenizer]]

#### transformers.ClvpTokenizer[[transformers.ClvpTokenizer]]

```python
transformers.ClvpTokenizer(vocab_file, merges_file, errors = 'replace', unk_token = '[UNK]', bos_token = '<|endoftext|>', eos_token = '[STOP]', pad_token = '[STOP]', add_prefix_space = False, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L73)

**パラメータ:**

vocab_file (`str`) : 語彙ファイルへのパス。

merges_file (`str`) : マージファイルへのパス。

errors (`str`、*任意*、デフォルトは`"replace"`) : バイトを UTF-8 にデコードする際に従うパラダイム。詳細は[bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)を参照してください。

unk_token (`str`、*任意*、デフォルトは `"[UNK]"`) : 不明トークン。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。

bos_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : シーケンスの開始トークン。

eos_token (`str`、*任意*、デフォルトは`"[STOP]"`) : シーケンスの終了トークン。

pad_token (`str`、*任意*、デフォルトは`"[STOP]"`) : シーケンスのパッドトークン。

add_prefix_space (`bool`、*任意*、デフォルトは `False`) : 入力に先頭スペースを追加するかどうか。これにより、先頭の単語を他の単語と同様に扱うことができます。(CLVP トークナイザーは、先行するスペースによって単語の開始を検出します)。

CLVPトークナイザーを構築します。バイトレベルのByte-Pair-Encodingに基づいています。

このトークナイザーは、スペースをトークンの一部として扱うように学習されています（sentencepieceに少し似ています）。そのため、単語は

文の先頭（スペースなし）にある場合と、そうでない場合とで、エンコードの仕方が異なります。

```python
>>> from transformers import ClvpTokenizer

>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]

>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]
```

この動作を回避するには、このトークナイザーをインスタンス化する際、またはテキストに対して呼び出す際に`add_prefix_space=True`を渡すことができます。ただし、モデルはこの方式で事前学習されていないため、パフォーマンスが低下する可能性があります。

`is_split_into_words=True` を使用する場合、このトークナイザーは各単語の前にスペースを追加します（最初の単語も含みます）。

このトークナイザーは、[PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しており、主要なメソッドのほとんどが含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

#### save_vocabulary[[transformers.ClvpTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362)

**パラメータ:**

save_directory (`str`) : 語彙を保存するディレクトリ。

filename_prefix (`str`, *任意*) : 保存されるファイルの名前に追加する任意のプレフィックス。

**戻り値:** `tuple[str, ...]`

保存されたファイルへのパス。ファイルが保存されていない場合は空のタプル。

一般的な語彙保存パターン向けのデフォルト実装。self.encoder/self.vocabをJSONとして保存し、必要に応じてself.bpe_ranksをマージとして保存します。語彙が存在しない場合は空のタプルを返します。

トークナイザーにカスタムの保存ロジック（SentencePieceモデル、複数の語彙ファイル、特殊なファイル形式など）が必要な場合は、このメソッドをオーバーライドしてください。

## ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

#### transformers.ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

```python
transformers.ClvpFeatureExtractor(feature_size = 80, sampling_rate = 22050, default_audio_length = 6, hop_length = 256, chunk_length = 30, n_fft = 1024, padding_value = 0.0, mel_norms = None, return_attention_mask = False, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L30)

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 80) : 抽出された特徴量の次元数。

sampling_rate (`int`、*optional*、デフォルトは 22050) : 音声ファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 単位）。

default_audio_length (`int`, *optional*, デフォルトは 6) : 生オーディオのデフォルトの長さ（秒）。`__call__` の呼び出し時に `max_length` が設定されていない場合、自動的に default_audio_length * `self.sampling_rate` に設定されます。

hop_length (`int`, *optional*, デフォルトは 256) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。

chunk_length (`int`、*任意*、デフォルトは 30) : より長いまたは短い音声シーケンスをトリムおよびパディングするために使用される、`sampling_rate` サンプルのチャンクの最大数。

n_fft (`int`、*optional*、デフォルトは 1024) : フーリエ変換のサイズ。

padding_value (`float`、*optional*、デフォルト値は 0.0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。

mel_norms (`list`、長さ `feature_size`、*任意*) : `mel_norms` が指定されている場合、各 mel フィルターに沿って log-mel スペクトログラムを正規化するために使用されます。

return_attention_mask (`bool`、*任意*、デフォルトは`False`) : attention mask を返すかどうか。デフォルトのままにすると、attention mask が返されます。[attention mask とは？](../glossary#attention-mask)

CLVPのフィーチャーエクストラクターを構築します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

このクラスは、`Short Time Fourier Transform`のカスタムなnumpy実装を使用して、生の音声からlog-melスペクトログラム特徴量を抽出します。この実装は、pytorchの`torch.stft`と同等の結果を出力するようになっています。

#### __call__[[transformers.ClvpFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = True, padding: str | None = 'max_length', max_length: int | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L128)

**パラメータ:**

raw_speech (`np.ndarray`、`list[float]`、`list[np.ndarray]`、`list[list[float]]`) : パディング対象のシーケンスまたはシーケンスのバッチです。各シーケンスは、NumPy 配列、浮動小数点数のリスト、NumPy 配列のリスト、または浮動小数点数のリストのリストであることができます。ステレオではなくモノラルのオーディオで、つまり 1 タイムステップあたり 1 つの浮動小数点数である必要があります。

sampling_rate (`int`, *任意*) : `raw_speech` 入力がサンプリングされたレートです。サイレントエラーを防ぎ、自動音声認識パイプラインを有効にするため、forward 呼び出し時に `sampling_rate` を渡すことを強く推奨します。

truncation (`bool`、*任意*、デフォルトは`True`) : 入力シーケンスの切り詰め処理を有効にし、*max_length*を超える長さのシーケンスを*max_length*まで短くします。

pad_to_multiple_of (`int`, *optional*) : 設定されている場合、シーケンスを指定された値の倍数にパディングします。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェアで Tensor Cores を使用可能にするため、またはシーケンス長が 128 の倍数であることで性能が向上する TPU で特に有用です。

return_attention_mask (`bool`、*任意*、デフォルトは`True`) : attention mask を返すかどうか。デフォルトのままにすると、attention mask が返されます。[attention mask とは？](../glossary#attention-mask)

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。

padding_value (`float`、*任意*、デフォルト値は 0.0) : パディングの値やベクトルに埋められる値。

max_length (`int`, *任意*) : 入力データの最大入力長。

`ClvpFeatureExtractor` は、サンプル音声や `raw_speech` から、音高や音色、話し速さ、さらには舌足らずや吃音といった発話上の欠陥など、音声固有のさまざまな特性を抽出するために使用されます。

まず、音声は`self.default_audio_length`秒の長さの波形になるようにパディングまたは切り詰められ、その後、そこからログメルスペクトログラムが抽出されます。

## ClvpProcessor[[transformers.ClvpProcessor]]

#### transformers.ClvpProcessor[[transformers.ClvpProcessor]]

```python
transformers.ClvpProcessor(feature_extractor, tokenizer)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L27)

**パラメータ:**

feature_extractor (`ClvpFeatureExtractor`) : 特徴量抽出器は必須の入力です。

tokenizer (`ClvpTokenizer`) : トークナイザーは必須の入力です。

ClvpProcessorを構築し、フィーチャーエクストラクターとトークナイザーを単一のプロセッサーにラップします。

[ClvpProcessor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpProcessor) は、[ClvpFeatureExtractor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor) と [ClvpTokenizer](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpTokenizer) のすべての機能を提供します。詳細については、[~ClvpFeatureExtractor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor) および [~ClvpTokenizer](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpTokenizer) を参照してください。

#### __call__[[transformers.ClvpProcessor.__call__]]

```python
__call__(*args, text = None, audio = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L31)

**パラメータ:**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

audio (``) : 準備対象のオーディオまたはオーディオのバッチ。各オーディオはNumPy配列またはPyTorchテンソルであることができます。NumPy配列/PyTorchテンソルの場合、各オーディオの形状は(C, T)である必要があります。ここで、Cはチャネル数、Tはオーディオのサンプル長を表します。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

#### decode[[transformers.ClvpProcessor.decode]]

```python
decode(*args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1961)

このメソッドは、すべての引数を PreTrainedTokenizer の [decode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) に転送します。詳細については、このメソッドのドキュメント文字列を参照してください。

#### batch_decode[[transformers.ClvpProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1952)

このメソッドは、すべての引数を PreTrainedTokenizer の [batch_decode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) に転送します。詳細については、このメソッドのドキュメント文字列を参照してください。

## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

#### transformers.ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

```python
transformers.ClvpModelForConditionalGeneration(config: ClvpConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1249)

**パラメータ:**

config ([ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

テキストエンコーダー、音声エンコーダー、音声デコーダーモデルを備えた複合CLVPモデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.ClvpModelForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1454)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [ClvpFeatureExtractor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor) を使用して取得できます。詳細は [ClvpFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__) を参照してください（[ClvpProcessor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpProcessor) は音声の処理に [ClvpFeatureExtractor](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpFeatureExtractor) を使用します）。

conditioning_encoder_inputs_embeds (`torch.FloatTensor`, *任意*) : `ClvpConditioningEncoder`用の inputs_embeds。`input_ids`の代わりに使用できます。

text_encoder_inputs_embeds (`torch.FloatTensor`、*任意*) : `input_ids` の代わりにテキストエンコーダーモデルに渡す inputs_embeds。

attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンインデックスに対する attention を行わないためのマスク。`[0, 1]` から選択されるマスク値:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

return_loss (`bool`, *任意*) : 対比損失を返すかどうか。

**戻り値:** `ClvpOutput` または `tuple(torch.FloatTensor)`

`ClvpOutput`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig)）と入力に応じて、さまざまな要素で構成されます。

[ClvpModelForConditionalGeneration](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpModelForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`return_loss` が `True` の場合のみ返されます) -- 音声とテキストの類似度に対する対比損失。
- **speech_ids** (`torch.LongTensor`、*任意*) -- `ClvpForCausalLM` モデルによって生成された speech_ids（または speech の候補）。
- **logits_per_speech** (`torch.FloatTensor`、shape `(speech_batch_size, text_batch_size)`) -- `speech_embeds`と`text_embeds`の間のスケーリングされたドット積スコアです。これは音声とテキストの類似度スコアを表します。
- **logits_per_text** (`torch.FloatTensor`、shape `(text_batch_size, speech_batch_size)`) -- `text_embeds` と `speech_embeds` 間のスケーリングされたドット積スコアです。これはテキストと音声の類似度スコアを表します。
- **text_embeds** (`torch.FloatTensor`、shape `(batch_size, output_dim`) -- テキストエンコーダーモデルのプーリング済み出力に投影層を適用して得られるテキスト埋め込み。
- **speech_embeds** (`torch.FloatTensor`、shape `(batch_size, output_dim`) -- speech encoder モデルのプーリング済み出力に投影層を適用して得られる speech embeddings です。
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`、*任意*) -- テキストエンコーダーモデルの `last_hidden_state` のプーリング済み出力です。
- **speech_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`、*任意*) -- 音声エンコーダモデルの `last_hidden_state` のプーリング済み出力です。
- **decoder_hidden_states** (`torch.FloatTensor`、*任意*) -- デコーダーモデルの隠れ状態です。
- **text_encoder_hidden_states** (`torch.FloatTensor`、*任意*) -- テキストエンコーダーモデルの隠れ状態です。
- **speech_encoder_hidden_states** (`torch.FloatTensor`、*任意*) -- 音声エンコーダーモデルの隠れ状態です。

例:

```python
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
...     input_ids=processor_output["input_ids"],
...     input_features=processor_output["input_features"],
...     return_dict=True,
... )
```

#### generate[[transformers.ClvpModelForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, pad_to_max_mel_tokens: int | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1563)

**パラメータ:**

input_ids (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力テキストのトークン。[ClvpTokenizer](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpTokenizer) で処理されたものです。

attention_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングテキストのトークンインデックスに対するアテンションを回避するためのマスク。`[0, 1]` から選択されるマスク値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

generation_config (`~generation.GenerationConfig`, *任意*) : 生成呼び出しのベースパラメータ化として使用される生成設定です。 `**kwargs` で `generation_config` の属性に一致するものが generate に渡された場合、それらが上書きされます。 `generation_config` が指定されない場合、デフォルトが使用されます。その読み込み優先順位は以下の通りです: 1) `generation_config.json` モデルファイルが存在する場合、そこから読み込む; 2) モデル設定から読み込む。 未指定のパラメータは [GenerationConfig](/docs/transformers/main/ja/main_classes/text_generation#transformers.GenerationConfig) のデフォルト値を継承することに注意してください。生成をパラメータ化するには、そのドキュメントを確認してください。

pad_to_max_mel_tokens (`int`, *optional*) : 生成された speech_ids を指定された値でパディングします。これは、公式リポジトリのロジックを再現し、logits が一致することを保証するために実装されています。リンク: https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 生成品質には影響しませんが、効率が悪いことから、使用を検討しないでください。

output_hidden_states (`bool`, *任意*) : デコーダーモデル、テキストエンコーダー、および音声エンコーダーモデルの隠れ状態を返すかどうかを指定します。

**戻り値:** `ClvpOutput` または tuple

`ClvpOutput`（`return_dict_in_generate=True` の場合、または `config.return_dict_in_generate=True` の場合）または、タプル。

`ClvpModelForConditionalGeneration` の `generate` メソッドです。このメソッドは `ClvpForCausalLM` の `generate` メソッドを呼び出し、生成された `speech_ids` を用いて `ClvpEncoder` で `text_embeds` と `speech_embeds` を処理します。

#### get_text_features[[transformers.ClvpModelForConditionalGeneration.get_text_features]]

```python
get_text_features(input_ids: typing.Optional[torch.LongTensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1317)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

text_encoder_inputs_embeds (`torch.FloatTensor`、*任意*) : `input_ids` の代わりにテキストエンコーダーモデルに渡す inputs_embeds。

attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンインデックスに対する attention を行わないためのマスク。`[0, 1]` から選択されるマスク値:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

**戻り値:** `ClvpEncoderOutput` または `tuple(torch.FloatTensor)`

`ClvpEncoderOutput`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig)）や入力に応じて、さまざまな要素で構成されます。

このメソッドは、テキストからtext_embedsを抽出するために使用できます。CLVPテキストエンコーダーモデルのプーリング済み出力に投影層を適用して得られるテキスト埋め込みです。

- **embeds**（`torch.FloatTensor`、形状 `(batch_size, output_dim)`、*任意*、モデルが `with_projection=True` で初期化された場合に返されます）-- pooler_output に投影層を適用して得られる埋め込み。
- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の隠れ状態です。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- `last_hidden_state`のプーリング済み出力。
- **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

```python
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text
>>> text = "This is an example text."

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])
```

#### get_speech_features[[transformers.ClvpModelForConditionalGeneration.get_speech_features]]

```python
get_speech_features(speech_ids: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1359)

**パラメータ:**

speech_ids (`torch.LongTensor`、shape `(batch_size, num_speech_ids)`、*optional*) : Speech Tokens。padding を指定した場合、デフォルトでは無視されます。speech_ids が指定された場合、input_ids と input_features は自動的に無視されます。

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力テキストのトークン。[ClvpTokenizer](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpTokenizer) で処理されたものです。speech_ids が指定されていない場合、input_ids と input_features が使用されます。

conditioning_encoder_inputs_embeds (`torch.FloatTensor`, *任意*) : `ClvpConditioningEncoder`用の inputs_embeds。`input_ids`の代わりに使用できます。

attention_mask (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングされた音声トークンインデックスに対するアテンションの適用を回避するためのマスク。`[0, 1]` から選択されるマスク値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

generation_config (`GenerationConfig`, *任意*) : speech_ids が提供されていない場合、その生成を制御するための generation config。

**戻り値:** `torch.FloatTensor`、形状 `(batch_size, output_dim)`

CLVP Speech Model のプーリング済み出力に投影層を適用して得られる音声埋め込み。

このメソッドは、speech_embedsを抽出するために使用できます。音声埋め込みは、speech_idsに音声モデルを適用することで取得されます。speech_idsが存在せず、input_idsとinput_featuresの両方が指定されている場合、デコーダーモデルがまずspeech_idsを生成し、その後音声モデルが適用されます。

例:

```python
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
...     input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )
```

## ClvpForCausalLM[[transformers.ClvpForCausalLM]]

#### transformers.ClvpForCausalLM[[transformers.ClvpForCausalLM]]

```python
transformers.ClvpForCausalLM(config: ClvpDecoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1071)

**パラメータ:**

config ([ClvpDecoderConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpDecoderConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

言語モデリングヘッドを上部に備えたCLVPデコーダーモデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.ClvpForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1187)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 言語モデリング用のラベル。モデル内部でラベルは**シフト**されるため、`labels = input_ids` と設定できます。インデックスは `[-100, 0, ..., config.vocab_size]` から選択されます。`-100` に設定されたすべてのラベルは無視（マスク）され、損失は `[0, ..., config.vocab_size]` 内のラベルに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) または `tuple(torch.FloatTensor)`

A [CausalLMOutputWithCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) or a tuple of `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the configuration ([ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig)) and inputs.

[ClvpForCausalLM](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpForCausalLM)のforwardメソッドは、`__call__`という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **cross_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンションのsoftmax後の重み。クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  シーケンシャルなデコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの hidden-states（アテンションブロック内のキーとバリュー）が含まれます。

## ClvpModel[[transformers.ClvpModel]]

#### transformers.ClvpModel[[transformers.ClvpModel]]

```python
transformers.ClvpModel(config: ClvpDecoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1015)

**パラメータ:**

config ([ClvpDecoderConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpDecoderConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

特定のヘッドを付加せず、生のhidden-statesを出力する素のClvp Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.ClvpModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1032)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) または `tuple(torch.FloatTensor)`

[BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions)、または`torch.FloatTensor`のタプル(`return_dict=False`が渡された場合、または`config.return_dict=False`の場合)。設定([ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig))と入力に応じて、さまざまな要素で構成されます。

[ClvpModel](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **cross_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合、または `config.add_cross_attention=True` が渡された場合、または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。

## ClvpEncoder[[transformers.ClvpEncoder]]

#### transformers.ClvpEncoder[[transformers.ClvpEncoder]]

```python
transformers.ClvpEncoder(config: ClvpEncoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L817)

**パラメータ:**

config : ClvpConfig

`config.num_hidden_layers` 個の自己アテンション層で構成される Transformer エンコーダーです。各層は `ClvpEncoderLayer` です。

#### forward[[transformers.ClvpEncoder.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L851)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

inputs_embeds (`torch.LongTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に便利です。

attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンインデックスに対する attention を行わないためのマスク。`[0, 1]` から選択されるマスク値:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

**戻り値:** `ClvpEncoderOutput` または `tuple(torch.FloatTensor)`

`ClvpEncoderOutput`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig)）や入力に応じて、さまざまな要素で構成されます。

[ClvpEncoder](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpEncoder)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **embeds**（`torch.FloatTensor`、形状 `(batch_size, output_dim)`、*任意*、モデルが `with_projection=True` で初期化された場合に返されます）-- pooler_output に投影層を適用して得られる埋め込み。
- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の隠れ状態です。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- `last_hidden_state`のプーリング済み出力。
- **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## ClvpDecoder[[transformers.ClvpDecoder]]

#### transformers.ClvpDecoder[[transformers.ClvpDecoder]]

```python
transformers.ClvpDecoder(config: ClvpDecoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L907)

*config.num_hidden_layers* 層で構成される Transformer デコーダーです。各層は `ClvpDecoderLayer` です。

#### forward[[transformers.ClvpDecoder.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L939)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) または `tuple(torch.FloatTensor)`

[BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions)、または`torch.FloatTensor`のタプル(`return_dict=False`が渡された場合、または`config.return_dict=False`の場合)。設定([ClvpConfig](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpConfig))と入力に応じて、さまざまな要素で構成されます。

[ClvpDecoder](/docs/transformers/main/ja/model_doc/clvp#transformers.ClvpDecoder)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **cross_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合、または `config.add_cross_attention=True` が渡された場合、または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。