# Pocket TTS

## 概要

Pocket TTSは[Kyutai](https://kyutai.org)が開発した1億パラメータのテキスト読み上げモデルで、CPU上でリアルタイムより高速に動作する[Continuous Audio Language Model](https://huggingface.co/papers/2509.06926)です。因果変換器が1ステップフローヘッドを介してフレームごとに1つの連続音声潜在変数（12.5 Hz）を出力し、発話終了ヘッドが停止のタイミングを判断します。

プロセッサは、[Pocket TTS audio tokenizer](./pocket_tts_audio_tokenizer)を保持しています。これは Mimi ベースのコーデックであり、音声プロンプトをエンコードし、生成された潜在変数を 24 kHz の音声にデコードします。事前定義された音声は KV キャッシュとして同梱されています（`voices/`）。

2つのフローヘッドがリリースされています:Lagrangian self-distillation(`flow_type="lsd"`、デフォルト)とdrifting(`flow_type="drifting"`、`english_drifting_26-09`)。ファインチューニングに対応しており、[Training](#training)を参照してください。

このモデルは [Eustache Le Bihan](https://huggingface.co/eustlb) によって提供されました。元のコードは [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts) です。

## 使用のコツ

- [apply_chat_template()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) を使用して入力を用意します（テキストごとに `user` メッセージを 1 つ、`add_generation_prompt=True` を指定）。トークナイザーの正規化処理は、チェックポイントの言語設定に基づいて、元のテキストと同様にテキストを準備します。
- `generate` は `audio_latents` と `audio_latents_mask` を返します。[PocketTTSProcessor.decode()](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) を使用してデコードしてください。
- `max_new_tokens` はデフォルトでテキストの長さに基づく予算が設定され、end-of-speech の logit が `eos_threshold` を超えた直後に生成が停止します。
- `do_sample=False`は、温度0の元の動作と一致します。サンプリングを行う場合、`temperature`（デフォルト0.3）は、フローの初期ノイズの分散です。
- 長いテキストは、[PocketTTSProcessor.split_text()](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text) を使用して分割し、チャンクごとに1つの会話にしてください。

## 使用方法

### ボイス

ボイスは3つの方法で指定できます。

**1. 録音のクローン作成**: 会話内の`audio`アイテム。

```python
from transformers import AutoModelForTextToWaveform, AutoProcessor

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

url = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/en-Alice_woman.wav"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "url": url},
            {"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."},
        ],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "cloned.wav")
```

**2. 事前計算済み潜在変数**: 空の`audio`項目で、潜在変数がプロセッサに渡されます。

```python
from transformers import AutoModelForTextToWaveform, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

# e.g. a recording encoded once by the processor's audio tokenizer,
# to reuse without re-encoding it
url = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/en-Alice_woman.wav"
features = processor.feature_extractor(
    load_audio(url, sampling_rate=24000), sampling_rate=24000
).to(processor.audio_tokenizer.device)
# (num_frames, latent_dim)
voice = processor.audio_tokenizer.encode(**features).latents[0]

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio"},
            {"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."},
        ],
    }
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    add_generation_prompt=True,
    processor_kwargs={"audio_prompt_latents": [voice]},
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "latents.wav")
```

**3. キャッシュされたコンテキスト**: 音声プロンプトのKVキャッシュで、`past_key_values`として渡されます。同梱の音声（`voices/`）はこの形式を使用しています。

```python
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

voice = load_file(hf_hub_download(model_id, "voices/alba.safetensors"))
layers = []
for i, layer in enumerate(model.model.layers):
    # each layer's cache on that layer's device
    device = layer.self_attn.k_proj.weight.device
    layers.append(
        (voice[f"layers.{i}.keys"].to(device), voice[f"layers.{i}.values"].to(device))
    )
voice_cache = DynamicCache(layers, config=model.config)

conversation = [
    {
        "role": "user",
        "content": [{"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."}],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(**inputs, past_key_values=voice_cache)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "cached.wav")
```

### バッチと長いテキスト

複数のテキストとボイスをバッチ処理し、長いテキストはチャンクに分割します:

```python
import torch
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

def load_voices(names):
    """The shipped voices, one per conversation, as one cache, left-padded to the
    longest voice, and the mask of their positions.

    `generate` extends the cache: load it for every call.
    """
    voices = [
        load_file(hf_hub_download(model_id, f"voices/{name}.safetensors"))
        for name in names
    ]
    lengths = [voice["layers.0.keys"].shape[2] for voice in voices]
    length = max(lengths)
    layers = []
    for i, layer in enumerate(model.model.layers):
        device = layer.self_attn.k_proj.weight.device
        keys, values = (
            torch.cat(
                [
                    torch.nn.functional.pad(voice[f"layers.{i}.{kind}"], (0, 0, length - n, 0))
                    for voice, n in zip(voices, lengths)
                ]
            ).to(device)
            for kind in ("keys", "values")
        )
        layers.append((keys, values))
    mask = torch.tensor([[0] * (length - n) + [1] * n for n in lengths])
    return DynamicCache(layers, config=model.config), mask

text = (
    "A first sentence that is long enough to be worth splitting. "
    "Then a second one, and a third one for good measure."
)
chunks = processor.split_text(text)
conversations = [
    [{"role": "user", "content": [{"type": "text", "text": chunk}]}]
    for chunk in chunks + ["Hello world"]
]
inputs = processor.apply_chat_template(
    conversations, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

voice_cache, voice_mask = load_voices(["alba"] * len(chunks) + ["jean"])
# the mask covers the cached voices too
inputs["attention_mask"] = torch.cat(
    [voice_mask.to(inputs["attention_mask"]), inputs["attention_mask"]], dim=-1
)
outputs = model.generate(**inputs, past_key_values=voice_cache)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(
    [torch.cat(audio[: len(chunks)]), audio[-1]], ["long.wav", "hello.wav"]
)
```

### ドリフトするチェックポイント

同じ使用方法で、チェックポイント自身のボイスを使用します:

```python
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts-english-drifting"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

voice = load_file(hf_hub_download(model_id, "voices/alba.safetensors"))
layers = []
for i, layer in enumerate(model.model.layers):
    device = layer.self_attn.k_proj.weight.device
    layers.append(
        (voice[f"layers.{i}.keys"].to(device), voice[f"layers.{i}.values"].to(device))
    )

conversation = [
    {
        "role": "user",
        "content": [{"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."}],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(
    **inputs, past_key_values=DynamicCache(layers, config=model.config)
)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "drifting.wav")
```

## トレーニング

ターゲットのオーディオを`assistant`ターンに配置します。プロセッサはラテンツを`labels`として返し、モデルは元の損失（LSD フロー損失に`config.eos_loss_weight`を掛けた発話終了損失を加えたもの）を返します。音声プロンプトは、通常、同じ発話の冒頭部分です。

```python
import torch
from transformers import AutoModelForTextToWaveform, AutoProcessor

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
model.train()

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "audio": voice_prompt},
            {"type": "text", "text": target_text},
        ],
    },
    {"role": "assistant", "content": [{"type": "audio", "audio": target_audio}]},
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True
).to(model.device)
loss = model(**inputs).loss
loss.backward()
```

- ボイスはキャッシュではなく、録音または潜在変数として指定してください。
- Classifier-free guidance を行う場合は、`user` ターン内の `audio` または `text` の項目を削除します（元の処理では、それぞれ 0.2 の確率で削除されます）。
- 事前計算された潜在変数は`processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`に格納され、空の`{"type": "audio"}`アイテムがプレースホルダーとして使用されます。
- 元のレシピ: AdamW、`learning_rate=2e-5`（新しい言語の場合は 2e-4）、`adam_beta2=0.95`、`weight_decay=0.1`、`max_grad_norm=1.0`、1000 ステップのウォームアップ後に一定、重みの EMA（減衰 0.999）。

## PocketTTSConfig[[transformers.PocketTTSConfig]]

#### transformers.PocketTTSConfig[[transformers.PocketTTSConfig]]

```python
transformers.PocketTTSConfig(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, flow_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocab_size: int = 4004, hidden_size: int = 1024, num_hidden_layers: int = 6, num_attention_heads: int = 16, num_key_value_heads: int | None = None, head_dim: int | None = None, intermediate_size: int = 4096, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-05, attention_bias: bool = False, attention_dropout: float = 0.0, max_position_embeddings: int = 8192, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, latent_dim: int = 32, pad_token_id: int = 3, bos_token_id: int | None = None, eos_token_id: int | None = None, audio_prompt_token_id: int = 4000, audio_latent_token_id: int = 4001, audio_prompt_bos_token_id: int = 4002, audio_bos_token_id: int = 4003, frame_rate: float = 12.5, initializer_range: float = 0.02, use_cache: bool = True, eos_loss_weight: float = 0.1, flow_loss_num_samples: int = 4, lsd_distill_probability: float = 0.25, lsd_diagonal_weight: float = 0.75, lsd_time_logit_mean: float = 0.4, lsd_time_logit_std: float = 1.0, latent_stats_ema_steps: int = 1000, latent_stats_ema_decay: float = 0.999)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L75)

**パラメータ:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *省略可*) : バックボーンの隠れ状態から各潜在変数をサンプリングするフローヘッドの設定です。

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

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

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

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

num_key_value_heads (`int`, *optional*) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA チェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。

head_dim (`int`, *optional*) : アテンションヘッドの次元です。None の場合、hidden_size // num_attention_heads がデフォルトとして使用されます。

intermediate_size (`int`、*任意*、デフォルトは`4096`) : MLP 表現の次元数。

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

layer_norm_eps (`float`、*任意*、デフォルトは 1e-05) : バックボーンのレイヤーノーマライゼーションのエプシロン。

attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。

attention_dropout (`float`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率です。

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

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれていなければならず、より長い `max_position_embeddings` で RoPE を使用する場合、スケーリングに使用されるパラメータが任意で含まれます。

latent_dim (`int`、*optional*、デフォルト値は 32) : バックボーンが入力として受け取るオーディオ潜在変数の次元数（`audio_prompt_latents`、`audio_latents`）。フローヘッドおよびオーディオトークナイザーの `latent_dim` と等しい。

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

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

eos_token_id (`int`, *任意*) : 語彙内でストリーム終了に使用されるトークン ID。

audio_prompt_token_id (`int`、*任意*、デフォルトは 4000) : `input_ids` 内の voice-prompt フレームのプレースホルダー トークン ID。

audio_latent_token_id (`int`, *optional*, デフォルトは 4001) : `input_ids` 内のオーディオ潜在位置のプレースホルダートークン ID。

audio_prompt_bos_token_id (`int`, *optional*, デフォルトは 4002) : 音声プロンプトの前に配置されるトークン ID。その埋め込みベクトルは、元のモデルが音声の先頭に付加する学習済みベクトルです。

audio_bos_token_id (`int`, *optional*, デフォルト値は 4003) : プロンプトを閉じる最初のオーディオ位置のトークン ID です。学習された BOS 潜在変数を保持し、そこから最初のフレームが生成されます。

frame_rate (`float`、*optional*、デフォルト値は 12.5) : 1 秒あたりのオーディオの潜在変数（latents）の数：`generate` は、これに基づいてデフォルトのフレーム予算を導出します。

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

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

eos_loss_weight (`float`、*任意*、デフォルト値は 0.1) : 学習損失における発話終了損失の重み。

flow_loss_num_samples (`int`、*optional*、デフォルトは 4) : フロー損失におけるターゲットフレームごとのノイズ抽選回数。

lsd_distill_probability (`float`、*optional*、デフォルト値は 0.25) : 各学習ステップにおいて、LSD ロスの自己蒸留項を計算する確率（期待損失を一定に保つために重み付けが再調整されます）。1 を指定すると、すべてのステップで計算されます。

lsd_diagonal_weight (`float`、*任意*、デフォルト値は 0.75) : LSD ロスの対角成分（即時フロー項）の重み。自己蒸留項は残りの部分を重み付けします。

lsd_time_logit_mean (`float`、*任意*、デフォルト値は 0.4) : LSD ロスによってサンプリングされるフロー時間のロジット正規分布の平均値。

lsd_time_logit_std (`float`、*任意*、デフォルト値は 1.0) : LSD ロスによってサンプリングされるフロー時間のロジット正規分布の標準偏差。

latent_stats_ema_steps (`int`、*optional*、デフォルトは 1000) : 最初の学習ステップの回数。この期間中、`latent_mean` と `latent_std` はターゲット潜在変数の指数移動平均に従います。0 に設定すると、これらは固定されます。

latent_stats_ema_decay (`float`, *任意*, デフォルト値は 0.999) : 移動平均の減衰率。

これはPocketTTSModelの設定を保存するための設定クラスです。指定された引数に基づいてPocket Ttsモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)と類似した設定が得られます。

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

## PocketTTSFlowHeadConfig[[transformers.PocketTTSFlowHeadConfig]]

#### transformers.PocketTTSFlowHeadConfig[[transformers.PocketTTSFlowHeadConfig]]

```python
transformers.PocketTTSFlowHeadConfig(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, hidden_size: int = 512, num_hidden_layers: int = 6, latent_dim: int = 32, condition_dim: int = 1024, frequency_embedding_size: int = 256, hidden_act: str = 'silu', layer_norm_eps: float = 1e-06, rms_norm_eps: float = 1e-05, max_period: float = 10000.0, flow_type: typing.Literal['lsd', 'drifting'] = 'lsd', loss_weighting_hidden_size: int = 32, loss_weighting_num_layers: int = 3)
```

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

**パラメータ:**

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

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

latent_dim (`int`、*optional*、デフォルトは 32) : ヘッドが予測する連続オーディオ潜在変数の次元（オーディオトークナイザーの潜在次元）。

condition_dim (`int`、*optional*、デフォルトは 1024) : ヘッドが条件付けられるバックボーンの隠れ状態の次元（バックボーンの`hidden_size`）。

frequency_embedding_size (`int`、*任意*、デフォルトは 256) : フロー時間の正弦波埋め込みのサイズ。

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

layer_norm_eps (`float`、*任意*、デフォルト値は 1e-06) : 残差ブロック内および最終層の層正規化のエプシロン。

rms_norm_eps (`float`、*任意*、デフォルトは 1e-05) : 時間埋め込みを閉じる正規化の Epsilon。

max_period (`float`, *任意*, デフォルト値は 10000.0) : 正弦波時間埋め込みの最大周期です。チェックポイントはこれを `freqs` として保存します。

flow_type (`str`、*任意*、デフォルトは `"lsd"`) : ヘッドが学習された目的関数であり、条件付けとサンプリングの方式を決定します。 `"lsd"`（ラグランジュ自己蒸留）: フローステップの開始時刻と終了時刻で条件付けられ、ガウスノイズからオイラー法でサンプリングされます。 `"drifting"`: 時刻による条件付けはなく、ヘッドが 1 回の呼び出しでノイズを潜在変数にマッピングします。

loss_weighting_hidden_size (`int`、*optional*、デフォルトは 32) : LSD ロスの各用語のフロータイムから不確実性重みを学習する MLP の幅（トレーニング時のみ）。

loss_weighting_num_layers (`int`、*任意*、デフォルトは 3) : その MLP の隠れ層の数。

これはPocketTTSModelの設定を保存するための設定クラスです。指定された引数に基づいてPocket Ttsモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)と類似した設定が得られます。

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

## PocketTTSFeatureExtractor[[transformers.PocketTTSFeatureExtractor]]

#### transformers.PocketTTSFeatureExtractor[[transformers.PocketTTSFeatureExtractor]]

```python
transformers.PocketTTSFeatureExtractor(feature_size = 1, sampling_rate = 24000, padding_value = 0.0, frame_size = 1920, pad_to_multiple_of = 1920, end_on_pause = True, pause_duration = 0.08, fade_out_duration = 0.02, silence_floor_db = 35.0, analysis_frame_duration = 0.02, **kwargs)
```

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

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 1) : チャネル数。

sampling_rate (`int`、*optional*、デフォルトは 24000) : 音声波形をデジタル化するためのサンプリングレート（ヘルツ (Hz) 表記）。

padding_value (`float`、*任意*、デフォルト値は 0.0) : パディングに使用される値。

frame_size (`int`、*optional*、デフォルトは 1920) : 音声トークナイザーの潜在フレームあたりの音声サンプル数（その`frame_size`）。

pad_to_multiple_of (`int`、*optional*、デフォルトは 1920) : 音声をこの値の倍数にパディングします。`frame_size` の倍数にすることで、すべての潜在フレームが完全に保持されます。

end_on_pause (`bool`、*任意*、デフォルトは`True`) : 各波形をちょうど`pause_duration`秒の無音で終わらせるかどうか: 末尾の無音（最大音量より`silence_floor_db`低い`analysis_frame_duration`秒のフレーム）は切り捨てられ、残りの最後の`fade_out_duration`秒はフェードアウトされ、`pause_duration`秒のゼロが追加されます。

pause_duration (`float`、*任意*、デフォルト値は 0.08) : `end_on_pause`によって追加される無音の長さ（秒）。

fade_out_duration (`float`、*任意*、デフォルト値は 0.02) : `end_on_pause` によってポーズ前に適用されるフェードアウトの持続時間（秒）。

silence_floor_db (`float`、*optional*、デフォルト値は 35.0) : 最も大きな解析フレームのレベルから dB 単位で下回った値。この値を下回る場合、`end_on_pause` は末尾のフレームを無音として扱います。

analysis_frame_duration (`float`、*任意*、デフォルト値は 0.02) : `end_on_pause` がレベルを測定するフレームの長さ（秒）。

Pocket TTSの機能抽出器を構築します。これは、音声プロンプトの波形をオーディオトークナイザーのエンコーダー用に準備します。

各波形は、短い休止で終わる場合があります（元の`end_on_pause`：学習用のプロンプトは2つの単語間の休止の途中で終わっており、発話で止まるプロンプトはモデルにその続きを生成させ、長い無音で終わるプロンプトは発話の開始を遅らせます）。その後、バッチはトークナイザーのフレームサイズの倍数になるよう右パディングされます。

#### __call__[[transformers.PocketTTSFeatureExtractor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, end_on_pause: bool | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy | None = True, pad_to_multiple_of: int | None = None, max_length: int | None = None, return_attention_mask: bool | None = True, return_tensors: str | None = 'pt', **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L106)

**パラメータ:**

audio (`np.ndarray`、`torch.Tensor`、`list[np.ndarray]`、`list[torch.Tensor]`) : 音声プロンプトのモノラル波形、またはモノラル波形のバッチです。

sampling_rate (`int`, *任意*) : `audio` 入力がサンプリングされたレートです。サイレントエラーを防ぐため、forward 呼び出し時に `sampling_rate` を渡すことを強く推奨します。

end_on_pause (`bool`, *任意*) : 各波形を短い休止で終わらせるかどうか。クラスドキュメントストリングを参照してください。デフォルトは`self.end_on_pause`です。

padding (`bool`、`str`または[PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*省略可能*、デフォルトは`True`) : バッチのパディング戦略。[pad()](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad)を参照してください。

pad_to_multiple_of (`int`, *optional*) : バッチをこの値の倍数にパディングします。デフォルトは `self.pad_to_multiple_of` です。

## PocketTTSProcessor[[transformers.PocketTTSProcessor]]

#### transformers.PocketTTSProcessor[[transformers.PocketTTSProcessor]]

```python
transformers.PocketTTSProcessor(feature_extractor, tokenizer, audio_tokenizer = None, chat_template = None, short_text_max_words: int = 4, frames_after_eos_short_text: int = 4, frames_after_eos: int = 2, fade_in_duration: float = 0.005)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L51)

**パラメータ:**

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

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

audio_tokenizer (`PocketTTSAudioTokenizerModel`、*任意*) : コーデックです。オーディオを潜在変数にエンコードし、生成された潜在変数をオーディオにデコードします。

chat_template (`str`) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。

short_text_max_words (`int`、*任意*、デフォルトは 4) : 最大この単語数のテキストには、発話終了フレームの後に `frames_after_eos_short_text` フレームが追加されます。

frames_after_eos_short_text (`int`、*optional*、デフォルトは 4) : 短いテキストの場合、発話終了フレームの後に生成されるフレーム数。

frames_after_eos (`int`、*optional*、デフォルトは 2) : 長いテキストの場合、発話終了フレームの後に生成されるフレーム数。

fade_in_duration (`float`、*optional*、デフォルト値は 0.005) : 各デコード済み波形の先頭に適用されるリニアフェードインの秒数です。新しいデコーダー状態は小さなステップから始まるため、クリック音として聞こえます。

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

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

#### __call__[[transformers.PocketTTSProcessor.__call__]]

```python
__call__(text: str | list[str] | None = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, audio_prompt_latents: list[torch.Tensor] | None = None, labels: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.models.pocket_tts.processing_pocket_tts.PocketTTSProcessorKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L109)

**パラメータ:**

text (`str` または `list[str]`) : [apply_chat_template()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) によってレンダリングされたプロンプト。

audio (`np.ndarray`、`torch.Tensor`、またはそれらのリスト、*任意*) : 会話の波形です。モノラル、24 kHz、会話の順序に従って配置されます。各音声、および学習時の各ターゲットです。

audio_prompt_latents (`list[torch.Tensor]`, *任意*) : 波形の代わりに、各ボイスプレースホルダーごとに1つの`(num_frames, latent_dim)`テンソルとして、事前計算されたボイス。

labels (`list[torch.Tensor]`, *任意*) : 事前計算されたターゲット（学習用）。波形の代わりに、ターゲットのプレースホルダーごとに `(num_frames, latent_dim)` のテンソルを1つずつ保持します。

end_on_pause (`bool`, *kwargs*, *optional*) : 元の処理と同様に、ボイスクローニングの前に短いポーズを挟むことで、各ボイスプロンプトの波形を終了させるかどうか。デフォルトでは、フィーチャーエクストラクターの`end_on_pause`が使用されます。

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

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。

**戻り値:**

`input_ids`、`attention_mask`、`audio_prompt_latents`、`audio_prompt_latents_mask` を持つ [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature)。生成には `frames_after_eos`（テキストの長さによる、発話終了フレームの後に生成されるフレーム数）、学習には `labels` と `labels_mask`。

#### split_text[[transformers.PocketTTSProcessor.split_text]]

```python
split_text(text: str, max_tokens: int = 50)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L282)

**パラメータ:**

text (`str`) : 分割するテキスト。

max_tokens (`int`、*任意*、デフォルトは 50) : チャンクあたりの最大トークン数。

`text`を、元の`split_into_best_sentences`と同様に、最大`max_tokens`トークンまでの文単位に整列したチャンクに分割します。準備されたテキストは、句点の後に切断されます（小数点では切断されません）。`max_tokens`を超える文は、句読点の後に切断されます。その後、各断片は貪欲にグループ化されます。各チャンクは、バッチの1つの会話として意図されています。

#### decode[[transformers.PocketTTSProcessor.decode]]

```python
decode(audio_latents: torch.Tensor, audio_latents_mask: torch.Tensor | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L340)

**パラメータ:**

audio_latents (`torch.Tensor`、形状は`(batch_size, num_frames, latent_dim)`または`(num_frames, latent_dim)`) : `generate`が返す潜在変数(`PocketTTSGenerateOutput.audio_latents`)を、1つのバッチとしてデコードしたもの、または1サンプル分の潜在変数。

audio_latents_mask (`torch.Tensor`、形状 `(batch_size, num_frames)`、*任意*) : 各サンプルのフレームのマスク (`PocketTTSGenerateOutput.audio_latents_mask`)。これを指定しない場合、すべての行がフルレングスでデコードされます。

**戻り値:**

CPU上の1次元波形の`list[torch.Tensor]`。行ごとに1つずつ、または1つのサンプルの潜在変数に対応する1つの波形。

生成された潜在変数をオーディオトークナイザーで波形にデコードし、元の動作と同様に、各波形の最初の`fade_in_duration`秒間をフェードインします。

#### save_audio[[transformers.PocketTTSProcessor.save_audio]]

```python
save_audio(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], saving_path: str | pathlib.Path | list[str | pathlib.Path], sampling_rate: int | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L389)

生成された波形をWAVファイルに書き込みます。

audio (`torch.Tensor`、`np.ndarray`、またはそれらのリスト): [decode()](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode)によって返される波形。saving_path (`str`、`Path`、またはそれらのリスト): 各波形に対応するパス。sampling_rate (`int`、*optional*): 波形のサンプリングレート。デフォルトでは、フィーチャーエクストラクター（オーディオトークナイザー）のものが使用されます。

## PocketTTSModel[[transformers.PocketTTSModel]]

#### transformers.PocketTTSModel[[transformers.PocketTTSModel]]

```python
transformers.PocketTTSModel(config: PocketTTSConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L498)

**パラメータ:**

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

Pocket TTSのバックボーン: 音声プロンプト、テキストトークン、オーディオ潜在変数からなる単一のストリームに対する因果変換器で、正規化された隠れ状態を返します。音声プロンプトとオーディオ潜在変数は、プロセッサが保持するオーディオトークナイザーの潜在変数です。

このモデルは [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.PocketTTSModel.forward]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L518)

**パラメータ:**

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)

audio_prompt_latents (`torch.Tensor`、形状 `(batch_size, num_prompt_frames, latent_dim)`、*任意*) : 音声トークナイザーのボイスプロンプトの潜在変数（プロセッサによってエンコードされたもの、またはチェックポイントの `voices/`）。バッチ内でもっとも長いボイスに合わせて右パディングが適用され、`audio_prompt_token_id` の位置に配置されています。

audio_prompt_latents_mask (`torch.Tensor`、shape `(batch_size, num_prompt_frames)`、*optional*) : `audio_prompt_latents` における音声フレーム（`1`）とパディング（`0`）を区別するためのマスク。

audio_latents (`torch.Tensor`、形状 `(batch_size, num_latents, latent_dim)`、*任意*) : `audio_latent_token_id` の位置に分散配置された正規化されたオーディオ潜在変数です。それらの直前にある `audio_bos_token_id` の位置は、プロンプトを閉じ、最初のフレームが生成される位置であり、常に学習された BOS 潜在変数が割り当てられます。

audio_latents_mask (`torch.Tensor`、shape `(batch_size, num_latents)`、*optional*) : `audio_latents` において、各行の latent の数（training）が異なる場合、各行の latent（`1`）と padding（`0`）を示すマスク。

attention_mask (`torch.Tensor`、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)

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

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

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

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

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

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

- **last_hidden_state** (`torch.Tensor`、形状 `(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.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

#### transformers.PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

```python
transformers.PocketTTSForConditionalGeneration(config: PocketTTSConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L672)

**パラメータ:**

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

Pocket TTS テキスト読み上げモデル: バックボーン、1ステップごとに1つのオーディオ潜在変数をサンプリングするフローヘッド、および発話終了ヘッド。このモデルはオーディオトークナイザーの潜在変数を生成し、プロセッサがそれを24 kHzのオーディオにデコードします。

このモデルは [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.PocketTTSForConditionalGeneration.forward]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L702)

**パラメータ:**

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)

audio_prompt_latents (`torch.Tensor`、形状 `(batch_size, num_prompt_frames, latent_dim)`、*任意*) : 音声トークナイザーのボイスポンプトの潜在変数。右パディングが適用され、`audio_prompt_token_id` の位置に配置されています。

audio_prompt_latents_mask (`torch.Tensor`、shape `(batch_size, num_prompt_frames)`、*optional*) : `audio_prompt_latents` における音声フレーム（`1`）とパディング（`0`）を区別するためのマスク。

audio_latents (`torch.Tensor`、形状 `(batch_size, num_latents, latent_dim)`、*任意*) : `audio_latent_token_id` の位置に分散配置された、正規化されたオーディオの潜在変数。

labels (`torch.Tensor`、形状 `(batch_size, num_frames, latent_dim)`、*任意*) : 音声トークナイザーのターゲット潜在変数（学習用）、右パディング済み。各行のプロンプトは `audio_bos_token_id` の位置で始まり、その後、フレームごとに 1 つの `audio_latent_token_id` 位置が続きます。モデルは正規化されたターゲット（ティーチャージング）を入力し、BOS と最終フレームを除くすべてのフレームの出力に対してフロー損失を適用します（これらはフレームを予測します）。また、それらすべてに対して発話終了損失を適用し、最後のフレームが発話の終了を表します。

labels_mask (`torch.Tensor`、shape `(batch_size, num_frames)`、*任意*) : `labels` における各行のターゲットフレーム (`1`) とパディング (`0`) を区別するためのマスク。

attention_mask (`torch.Tensor`、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)

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

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

**戻り値:** `PocketTTSOutputWithPast` または `tuple(torch.Tensor)`

`PocketTTSOutputWithPast`または`torch.Tensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。[PocketTTSConfig](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSConfig)および入力に応じて、さまざまな要素で構成されます。

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

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

- **loss** (`torch.Tensor`、shape `()`、*optional*、`labels` が渡された場合に返されます) -- 学習損失: ターゲットの潜在変数の LSD フロー損失に、`config.eos_loss_weight` 倍の発話終了損失を加えたものです。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, 1)`) -- 音声終了の logits。各位置ごとに 1 つ。
- **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** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- フローヘッドを条件づける、バックボーンの正規化された隠れ状態です。

例:

```python
>>> from transformers import AutoProcessor, PocketTTSForConditionalGeneration

>>> model = PocketTTSForConditionalGeneration.from_pretrained("eustlb/pocket-tts")

>>> processor = AutoProcessor.from_pretrained("eustlb/pocket-tts")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

>>> # generate speech
>>> speech = model(inputs["input_ids"])
```

#### generate[[transformers.PocketTTSForConditionalGeneration.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/generation_pocket_tts.py#L122)

**パラメータ:**

inputs (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : [PocketTTSProcessor](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor) によって準備された `input_ids` です。`input_ids=` として渡すこともできます。

kwargs (`dict[str, Any]`, *省略可*) : `attention_mask`、音声プロンプト（`audio_prompt_latents` と `audio_prompt_latents_mask`、またはテキストのみプロンプトを持つ出荷済み音声の音声プレフィックスのキャッシュである `past_key_values`）、プロセッサからの `frames_after_eos`、生成パラメータ（`do_sample`、`temperature`、`max_new_tokens` など）、および Pocket TTS 固有の `num_flow_steps`、`eos_threshold`、`min_frames_before_eos`（デフォルトでは生成設定の値を使用します）。

**戻り値:**

`return_dict_in_generate=True`（チェックポイントの生成設定）の場合、[PocketTTSGenerateOutput](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) が返されます。これはパディング済みの`audio_latents`と、それに対応する`audio_latents_mask`を含み、[PocketTTSProcessor.decode()](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode)によって1つのバッチとしてデコードされます。それ以外の場合は、生成された潜在変数のリストが返され、各サンプルに対して`(num_frames, latent_dim)`のテンソルが1つ含まれ、それぞれが個別にデコードされます。

音声の生成を行います。このメソッドは [generate()](/docs/transformers/main/ja/main_classes/text_generation#transformers.GenerationMixin.generate) をオーバーライドし、`max_new_tokens` のデフォルト値を、バッチ内でもっとも長いテキストに対する元のランタイムのフレーム予算である `ceil((num_text_tokens / 3 + 2) * frame_rate)` に設定します。その他の処理は、通常の生成フックを通じて行われます。

#### sample_latent[[transformers.PocketTTSForConditionalGeneration.sample_latent]]

```python
sample_latent(condition: Tensor, noise: Tensor, num_flow_steps: int)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L807)

**パラメータ:**

condition (`torch.Tensor`、形状 `(batch_size, hidden_size)`) : 生成中の位置の Backbone の隠れ状態。

noise (`torch.Tensor`、形状 `(batch_size, latent_dim)`) : `sqrt(temperature)` 倍でスケーリングされたガウスノイズ、またはゼロ。

num_flow_steps (`int`) : LSDサンプラーのEulerステップ数（drifting headは1回の呼び出しで処理するため、無視されます）。

**戻り値:** `torch.Tensor`、形状は `(batch_size, latent_dim)`

正規化空間におけるサンプリングされた潜在変数。

フローヘッドを使用して、`noise`から次の潜在変数をサンプリングします。

#### denormalize_latents[[transformers.PocketTTSForConditionalGeneration.denormalize_latents]]

```python
denormalize_latents(audio_latents: Tensor)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L854)

フローヘッドの正規化空間から、オーディオトークナイザーの空間へ潜在変数をマッピングします。

## PocketTTSGenerateOutput[[transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput]]

#### transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput[[transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput]]

```python
transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, audio_latents: typing.Optional[torch.Tensor] = None, audio_latents_mask: typing.Optional[torch.LongTensor] = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/generation_pocket_tts.py#L40)

**パラメータ:**

sequences (`torch.LongTensor`、形状 `(batch_size, sequence_length)`) : プロンプトのトークンIDに続き、生成された各フレームごとに1つの`audio_latent_token_id`が続きます。音声自体は`audio_latents`に含まれています。

scores (`tuple(torch.Tensor)` *任意*、`output_scores=True` の場合のみ返されます) : 生成された各フレームの発話終了（end-of-speech）の logit です。フレームごとに、形状が `(batch_size,)` のテンソルが 1 つ返されます。

logits (`tuple(torch.Tensor)` *任意*、`output_logits=True` の場合のみ返されます) : `scores` と同じです。Pocket TTS には語彙がないため、この 2 つの間で処理するものは何もありません。

attentions (`tuple(tuple(torch.Tensor))`、*optional*、`output_attentions=True` の場合に返されます) : 生成された各フレームごとに1要素、各レイヤーごとに1要素を持つ `torch.Tensor` のタプルのタプルで、各 `torch.Tensor` の形状は `(batch_size, num_heads, generated_length, sequence_length)` です。

hidden_states (`tuple(tuple(torch.Tensor))`、*optional*、`output_hidden_states=True` の場合に返されます) : 生成された各フレームに対応する要素を持つタプルで、各要素は各レイヤーに対応する要素を持つタプルであり、その形状は `(batch_size, generated_length, hidden_size)` の `torch.Tensor` です。

past_key_values (`Cache`, *任意*, `use_cache=True` の場合のみ返されます) : 生成の終了時点でのバックボーンのキー/バリューキャッシュ。

audio_latents (`torch.Tensor`、形状 `(batch_size, num_frames, latent_dim)`) : 生成された潜在変数です。これはオーディオトークナイザーの潜在空間にあり、各サンプルのフレーム数を超えた部分はゼロで右パディングされています。[PocketTTSProcessor.decode()](/docs/transformers/main/ja/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) を使用すると、これらは波形に変換されます。

audio_latents_mask (`torch.LongTensor`、形状 `(batch_size, num_frames)`) : 各サンプルのフレームのマスク。パディング (`0`) とは異なり、発話終了フレームとその後のフレームを含む (`1`)。

`PocketTTSForConditionalGeneration.generate`の出力。