# Pocket TTS

## Ikhtisar

Pocket TTS adalah model text-to-speech 100M parameter dari [Kyutai](https://kyutai.org), sebuah [Continuous Audio Language Model](https://huggingface.co/papers/2509.06926) yang berjalan lebih cepat dari waktu nyata pada CPU. Transformer kausal mengeluarkan satu latent audio kontinu per frame (12.5 Hz) melalui one-step flow head, dan end-of-speech head menentukan kapan harus berhenti.

Processor menyimpan [Pocket TTS audio tokenizer](./pocket_tts_audio_tokenizer), sebuah codec berbasis Mimi yang mengenkripsi prompt suara dan mendekode latens yang dihasilkan menjadi audio 24 kHz. Suara yang sudah didefinisikan sebelumnya disertakan sebagai KV cache (`voices/`).

Dua flow head dirilis: Lagrangian self-distillation (`flow_type="lsd"`, default) dan drifting (`flow_type="drifting"`, `english_drifting_26-09`). Finetuning didukung, lihat [Training](#training).

Model ini disumbangkan oleh [Eustache Le Bihan](https://huggingface.co/eustlb). Kode aslinya adalah [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts).

## Tips penggunaan

- Siapkan input dengan [apply_chat_template()](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (satu pesan `user` per teks, `add_generation_prompt=True`). Normalizer dari tokenizer menyiapkan teks seperti aslinya, dengan pengaturan bahasa dari checkpoint.
- `generate` mengembalikan `audio_latents` dan `audio_latents_mask`; dekodekan dengan [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- `max_new_tokens` secara default menggunakan anggaran berdasarkan panjang teks, dan generasi berhenti segera setelah logit akhir ucapan melampaui `eos_threshold`.
- `do_sample=False` sesuai dengan kondisi asli pada suhu 0. Dengan sampling, `temperature` (default 0.3) adalah varians dari noise awal aliran.
- Pisahkan teks panjang dengan [PocketTTSProcessor.split_text()](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), satu percakapan per chunk.

## Penggunaan

### Suara

Suara dapat diberikan dengan tiga cara.

**1. Mengkloning rekaman**: item `audio` dalam percakapan.

```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. Laten yang sudah dihitung**: item `audio` kosong, dengan laten yang diteruskan ke prosesor.

```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. Konteks yang di-cache**: cache KV dari prompt suara, yang diteruskan sebagai `past_key_values`. Suara bawaan (`voices/`) menggunakan bentuk ini.

```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")
```

### Batch dan teks panjang

Batch beberapa teks dan suara, dengan teks panjang dipecah menjadi chunk:

```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"]
)
```

### Checkpoint yang bergeser

Penggunaan yang sama, dengan suara milik checkpoint itu sendiri:

```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")
```

## Pelatihan

Letakkan audio target pada giliran `assistant`. Prosesor mengembalikan latennya sebagai `labels`, dan model mengembalikan loss dari audio asli (loss aliran LSD ditambah `config.eos_loss_weight` kali loss akhir ucapan). Prompt suara biasanya merupakan bagian awal dari ucapan yang sama.

```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()
```

- Beri suara sebagai rekaman atau latents, bukan cache.
- Untuk classifier-free guidance, hilangkan item `audio` atau `text` dari giliran `user` (aslinya menghilangkan masing-masing dengan probabilitas 0,2).
- Latents yang sudah dihitung sebelumnya dimasukkan ke dalam `processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`, dengan item `{"type": "audio"}` kosong sebagai placeholder.
- Resep asli: AdamW, `learning_rate=2e-5` (2e-4 untuk bahasa baru), `adam_beta2=0.95`, `weight_decay=0.1`, `max_grad_norm=1.0`, 1000 langkah warmup lalu konstan, EMA dari bobot (decay 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L75)

**Parameter:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *opsional*) : Konfigurasi dari flow head yang mengambil sampel setiap latent dari hidden state backbone.

vocab_size (`int`, *opsional*, defaultnya `4004`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `1024`) : Dimensi dari representasi tersembunyi.

num_hidden_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `16`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

num_key_value_heads (`int`, *opsional*) : Ini adalah jumlah key_value heads yang harus digunakan untuk mengimplementasikan Grouped Query Attention. Jika `num_key_value_heads=num_attention_heads`, model akan menggunakan Multi Head Attention (MHA), jika `num_key_value_heads=1` model akan menggunakan Multi Query Attention (MQA), selain itu GQA yang digunakan. Saat mengonversi checkpoint multi-head menjadi checkpoint GQA, setiap group key dan value head harus dibangun dengan meanpooling semua head asli di dalam grup tersebut. Untuk detail lebih lanjut, lihat [paper ini](https://huggingface.co/papers/2305.13245). Jika tidak ditentukan, akan default ke `num_attention_heads`.

head_dim (`int`, *opsional*) : Dimensi kepala perhatian. Jika None, nilainya akan secara default menjadi hidden_size // num_attention_heads

intermediate_size (`int`, *opsional*, defaultnya `4096`) : Dimensi dari representasi MLP.

hidden_act (`str`, *opsional*, defaultnya `gelu_pytorch_tanh`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, default 1e-05) : Epsilon dari layer normalizations pada backbone.

attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

attention_dropout (`float`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

max_position_embeddings (`int`, *opsional*, defaultnya `8192`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opsional*) : Dictionary yang berisi parameter konfigurasi untuk embedding RoPE. Dictionary harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk scaling jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang.

latent_dim (`int`, *opsional*, default 32) : Dimensi dari latens audio yang diterima backbone sebagai input (`audio_prompt_latents`, `audio_latents`); sama dengan `latent_dim` dari flow head dan audio tokenizer.

pad_token_id (`int`, *opsional*, defaultnya `3`) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*) : ID token yang digunakan untuk awal aliran dalam kosakata.

eos_token_id (`int`, *opsional*) : ID token yang digunakan untuk akhir aliran dalam kosakata.

audio_prompt_token_id (`int`, *opsional*, default 4000) : ID token placeholder untuk frame voice-prompt di `input_ids`.

audio_latent_token_id (`int`, *opsional*, default 4001) : ID token placeholder untuk posisi laten audio di `input_ids`.

audio_prompt_bos_token_id (`int`, *opsional*, default 4002) : Token id yang ditempatkan sebelum prompt suara; embedding-nya adalah vektor yang dipelajari dan di-prepend oleh model asli ke suara.

audio_bos_token_id (`int`, *opsional*, default 4003) : Token id dari posisi audio pertama, menutup prompt: menyimpan laten BOS yang dipelajari, yang menjadi dasar untuk menghasilkan frame pertama.

frame_rate (`float`, *opsional*, default 12.5) : Jumlah latens audio per detik audio: `generate` menurunkan anggaran frame defaultnya darinya.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

use_cache (`bool`, *opsional*, defaultnya `True`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder.

eos_loss_weight (`float`, *opsional*, default 0.1) : Bobot dari kerugian akhir-bicara (end-of-speech) dalam kerugian pelatihan.

flow_loss_num_samples (`int`, *opsional*, default 4) : Jumlah pengundian noise per bingkai target dalam flow loss.

lsd_distill_probability (`float`, *opsional*, default 0.25) : Probabilitas, per langkah pelatihan, untuk menghitung istilah self-distillation dari loss LSD (diberat ulang untuk menjaga loss yang diharapkan); 1 menghitungnya di setiap langkah.

lsd_diagonal_weight (`float`, *opsional*, default 0.75) : Bobot dari istilah diagonal (aliran instan) dari loss LSD; istilah self-distillation menimbang sisanya.

lsd_time_logit_mean (`float`, *opsional*, default 0.4) : Rata-rata dari distribusi logit-normal dari waktu aliran yang diambil oleh kerugian LSD.

lsd_time_logit_std (`float`, *opsional*, default 1.0) : Standar deviasi dari distribusi logit-normal dari waktu alur yang diambil oleh kerugian LSD.

latent_stats_ema_steps (`int`, *opsional*, default 1000) : Jumlah langkah pelatihan awal di mana `latent_mean` dan `latent_std` mengikuti rata-rata bergerak eksponensial dari latens target; 0 membuat keduanya tetap beku.

latent_stats_ema_decay (`float`, *opsional*, default 0.999) : Peluruhan dari rata-rata bergerak tersebut.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PocketTTSModel. Kelas ini digunakan untuk membuat instans model Pocket Tts berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L27)

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `512`) : Dimensi dari representasi tersembunyi.

num_hidden_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

latent_dim (`int`, *opsional*, default 32) : Dimensi dari latens audio kontinu yang diprediksi oleh head (dimensi latens dari tokenizer audio).

condition_dim (`int`, *optional*, defaults to 1024) : Dimension of the backbone hidden state the head is conditioned on (the backbone `hidden_size`).

frequency_embedding_size (`int`, *opsional*, default 256) : Ukuran embedding sinusoidal dari waktu aliran.

hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, default 1e-06) : Epsilon dari layer normalizations di dalam residual blocks dan layer terakhir.

rms_norm_eps (`float`, *opsional*, default 1e-05) : Epsilon dari normalisasi yang menutup time embeddings.

max_period (`float`, *opsional*, default 10000.0) : Periode maksimum dari penanaman waktu sinusoidal, yang disimpan checkpoint sebagai `freqs`.

flow_type (`str`, *opsional*, defaultnya `"lsd"`) : Tujuan yang digunakan untuk melatih head, yang menentukan bagaimana head tersebut dikondisikan dan disampelkan. `"lsd"` (distilasi diri Lagrangian): dikondisikan pada waktu awal dan akhir dari langkah aliran, disampelkan dengan langkah Euler dari noise Gaussian. `"drifting"`: tanpa kondisioning waktu, head memetakan noise ke laten dalam satu pemanggilan.

loss_weighting_hidden_size (`int`, *opsional*, default 32) : Lebar MLP yang mempelajari penimbangan ketidakpastian dari istilah-istilah loss LSD dari waktu alir mereka (hanya untuk pelatihan).

loss_weighting_num_layers (`int`, *opsional*, defaultnya 3) : Jumlah lapisan tersembunyi dari MLP tersebut.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PocketTTSModel. Kelas ini digunakan untuk membuat instans model Pocket Tts berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L29)

**Parameter:**

feature_size (`int`, *opsional*, default 1) : Jumlah channel.

sampling_rate (`int`, *opsional*, default 24000) : Laju sampling di mana gelombang audio harus didigitalisasi, dinyatakan dalam hertz (Hz).

padding_value (`float`, *opsional*, default 0.0) : Nilai yang digunakan untuk padding.

frame_size (`int`, *opsional*, default 1920) : Jumlah sampel audio per frame laten dari audio tokenizer (yaitu `frame_size`nya).

pad_to_multiple_of (`int`, *opsional*, default 1920) : Pad audio menjadi kelipatan dari nilai ini; kelipatan dari `frame_size` menjaga setiap frame laten tetap utuh.

end_on_pause (`bool`, *opsional*, defaultnya `True`) : Apakah setiap waveform diakhiri tepat dengan `pause_duration` detik keheningan: keheningan di akhir (frame `analysis_frame_duration` detik yang lebih dari `silence_floor_db` di bawah yang paling keras) dipotong, `fade_out_duration` detik terakhir dari yang tersisa diredupkan, dan `pause_duration` detik nol ditambahkan.

pause_duration (`float`, *opsional*, default 0.08) : Durasi keheningan yang ditambahkan oleh `end_on_pause`, dalam detik.

fade_out_duration (`float`, *opsional*, default 0.02) : Durasi fade-out yang diterapkan oleh `end_on_pause` sebelum jeda, dalam detik.

silence_floor_db (`float`, *opsional*, default 35.0) : Level di bawah frame analisis paling keras, dalam dB, di mana `end_on_pause` memperlakukan frame berujung sebagai keheningan.

analysis_frame_duration (`float`, *opsional*, default 0.02) : Durasi frame yang diukur tingkatnya oleh `end_on_pause`, dalam detik.

Membangun fitur ekstraktor Pocket TTS, yang menyiapkan waveform prompt suara untuk encoder tokenizer audio.

Setiap gelombang suara secara opsional diakhiri dengan jeda singkat (`end_on_pause` dari versi asli: prompt pelatihan berakhir di dalam jeda antara dua kata, prompt yang berhenti pada ucapan membuat model melanjutkannya, dan prompt yang berakhir pada keheningan panjang menunda permulaan), kemudian batch di-pad ke kanan hingga menjadi kelipatan ukuran frame tokenizer.

#### __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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L106)

**Parameter:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Gelombang mono atau batch gelombang mono dari prompt suara.

sampling_rate (`int`, *opsional*) : Laju pengambilan sampel di mana input `audio` diambil. Sangat disarankan untuk meneruskan `sampling_rate` pada panggilan forward untuk mencegah kesalahan yang tidak terdeteksi.

end_on_pause (`bool`, *opsional*) : Apakah mengakhiri setiap gelombang suara dengan jeda singkat, lihat docstring kelas. Bawaan adalah `self.end_on_pause`.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `True`) : Strategi padding untuk batch, lihat [pad()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

pad_to_multiple_of (`int`, *opsional*) : Pad batch menjadi kelipatan dari nilai ini. Defaultnya adalah `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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L49)

**Parameter:**

feature_extractor (`PocketTTSFeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

tokenizer (`TokenizersBackend`) : Tokenizer adalah input yang wajib.

audio_tokenizer (`PocketTTSAudioTokenizerModel`, *opsional*) : Codec: mengodekan audio menjadi latents, dan mendekodekan latents yang dihasilkan menjadi audio.

chat_template (`str`) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

short_text_max_words (`int`, *opsional*, default 4) : Teks dengan jumlah kata paling banyak ini akan mendapatkan `frames_after_eos_short_text` frame setelah frame end-of-speech.

frames_after_eos_short_text (`int`, *opsional*, default 4) : Jumlah frame yang dihasilkan setelah frame akhir ucapan untuk teks pendek.

frames_after_eos (`int`, *opsional*, default 2) : Jumlah frame yang dihasilkan setelah frame akhir ucapan untuk teks yang lebih panjang.

fade_in_duration (`float`, *opsional*, default 0.005) : Durasi dalam detik dari fade-in linear yang diterapkan pada awal setiap waveform yang didekodekan: status decoder yang baru dimulai dengan langkah kecil, terdengar sebagai klik.

Membangun PocketTTSProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[PocketTTSProcessor](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor) menyediakan semua fungsionalitas dari [PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) dan [TokenizersBackend](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend). Lihat [~PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) dan [~TokenizersBackend](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend) untuk informasi lebih lanjut.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L107)

**Parameter:**

text (`str` atau `list[str]`) : Prompt yang dirender oleh [apply_chat_template()](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

audio (`np.ndarray`, `torch.Tensor`, atau daftar dari keduanya, *opsional*) : Gelombang suara dari percakapan, mono pada 24 kHz, dalam urutan percakapan: setiap suara, dan dalam pelatihan setiap target.

audio_prompt_latents (`list[torch.Tensor]`, *opsional*) : Suara yang sudah dihitung sebelumnya, satu tensor `(num_frames, latent_dim)` per placeholder suara, alih-alih waveform.

labels (`list[torch.Tensor]`, *opsional*) : Target yang sudah dihitung sebelumnya (pelatihan), satu tensor `(num_frames, latent_dim)` per placeholder target, alih-alih waveform.

end_on_pause (`bool`, *kwargs*, *opsional*) : Apakah mengakhiri setiap waveform voice-prompt dengan jeda singkat, seperti yang dilakukan versi asli sebelum mengkloning suara. Nilai defaultnya adalah `end_on_pause` dari feature extractor.

return_mm_token_type_ids (`bool`, *kwargs*) : Apakah akan mengembalikan id tipe token multimodal yang menunjukkan posisi token placeholder multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Apakah akan mengembalikan offset karakter untuk setiap placeholder multimodal dan pengantinya.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:**

[BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature) dengan `input_ids`, `attention_mask`, `audio_prompt_latents` dan `audio_prompt_latents_mask`; untuk generasi `frames_after_eos` (frame yang dihasilkan setelah frame end-of-speech, berdasarkan panjang teks), untuk pelatihan `labels` dan `labels_mask`.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L281)

**Parameter:**

text (`str`) : Teks yang akan dipecah.

max_tokens (`int`, *opsional*, default 50) : Jumlah maksimum token per chunk.

Memecah `text` menjadi potongan yang selaras dengan kalimat, dengan panjang maksimal `max_tokens` token, seperti pada `split_into_best_sentences` versi asli: teks yang disiapkan dipotong setelah akhir kalimat (bukan pada titik desimal), kalimat yang lebih panjang dari `max_tokens` dipotong setelah akhir klausa, dan potongan-potongan tersebut dikelompokkan secara serakah. Setiap potongan dimaksudkan sebagai satu percakapan dalam batch.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L339)

**Parameter:**

audio_latents (`torch.Tensor` dengan bentuk `(batch_size, num_frames, latent_dim)` atau `(num_frames, latent_dim)`) : Latents yang dikembalikan oleh `generate` (`PocketTTSGenerateOutput.audio_latents`), didekodekan sebagai satu batch, atau latents dari satu sampel.

audio_latents_mask (`torch.Tensor` dengan bentuk `(batch_size, num_frames)`, *opsional*) : Mask untuk frame dari setiap sampel (`PocketTTSGenerateOutput.audio_latents_mask`). Tanpa mask ini, setiap baris akan didekodekan pada panjang penuh.

**Mengembalikan:**

`list[torch.Tensor]` berisi waveform 1D di CPU, satu per baris, atau satu waveform untuk latents satu sampel.

Mendekodekan latens yang dihasilkan menjadi waveform dengan audio tokenizer, dan memudarkan `fade_in_duration` detik pertama dari masing-masing, seperti yang dilakukan versi aslinya.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L388)

Menulis gelombang suara yang dihasilkan ke file WAV.

audio (`torch.Tensor`, `np.ndarray` atau daftar dari keduanya): Gelombang suara, sebagaimana dikembalikan oleh [decode()](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode). saving_path (`str`, `Path` atau daftar dari keduanya): Satu path per gelombang suara. sampling_rate (`int`, *opsional*): Laju sampling dari gelombang suara, secara default menggunakan milik feature extractor (audio tokenizer).

## PocketTTSModel[[transformers.PocketTTSModel]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L498)

**Parameter:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Backbone Pocket TTS: transformer kausal di atas satu aliran yang terdiri dari prompt suara, token teks, dan latens audio, yang mengembalikan hidden states ternormalisasi. Prompt suara dan latens audio adalah latens dari tokenizer audio, yang dipegang oleh processor.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L518)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` dengan bentuk `(batch_size, num_prompt_frames, latent_dim)`, *opsional*) : Latents voice-prompt dari audio tokenizer (dikonkoding oleh processor, atau `voices/` dari checkpoint), di-right-pad hingga voice terpanjang dalam batch, dan disebar ke posisi `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` dengan bentuk `(batch_size, num_prompt_frames)`, *opsional*) : Mask dari frame suara (`1`) berbanding padding (`0`) dalam `audio_prompt_latents`.

audio_latents (`torch.Tensor` dengan bentuk `(batch_size, num_latents, latent_dim)`, *opsional*) : Laten audio ternormalisasi, yang tersebar ke posisi `audio_latent_token_id`. Posisi `audio_bos_token_id` sebelum posisi tersebut, yang menutup prompt dan menjadi titik awal generasi frame pertama, selalu menerima laten BOS yang dipelajari.

audio_latents_mask (`torch.Tensor` dengan bentuk `(batch_size, num_latents)`, *opsional*) : Mask untuk latents pada setiap baris (`1`) dibandingkan dengan padding (`0`) di `audio_latents`, ketika baris-baris tersebut memiliki jumlah posisi latent yang berbeda (pelatihan).

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PocketTTSConfig](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSConfig)) dan input.

Metode forward dari [PocketTTSModel](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L672)

**Parameter:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model text-to-speech Pocket TTS: tulang punggung, kepala aliran yang mengambil satu laten audio per langkah, dan kepala akhir ucapan. Model ini menghasilkan laten tokenizer audio, yang kemudian didekodekan oleh prosesor menjadi audio 24 kHz.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L702)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` dengan bentuk `(batch_size, num_prompt_frames, latent_dim)`, *opsional*) : Latent voice-prompt dari audio tokenizer, di-padded di sisi kanan, dan tersebar ke posisi `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` dengan bentuk `(batch_size, num_prompt_frames)`, *opsional*) : Mask dari frame suara (`1`) berbanding padding (`0`) dalam `audio_prompt_latents`.

audio_latents (`torch.Tensor` dengan bentuk `(batch_size, num_latents, latent_dim)`, *opsional*) : Laten audio ternormalisasi, tersebar ke posisi `audio_latent_token_id`.

labels (`torch.Tensor` dengan bentuk `(batch_size, num_frames, latent_dim)`, *opsional*) : Latent target dari audio tokenizer (pelatihan), dengan padding kanan. Prompt pada setiap baris diakhiri oleh posisi `audio_bos_token_id` yang diikuti oleh satu posisi `audio_latent_token_id` per frame: model memberikan target yang dinormalisasi (teacher forcing), menerapkan flow loss pada output dari BOS dan semua frame kecuali frame terakhir, yang memprediksi frame-frame tersebut, serta menerapkan end-of-speech loss pada semuanya, dengan yang terakhir merupakan end of speech.

labels_mask (`torch.Tensor` dengan bentuk `(batch_size, num_frames)`, *opsional*) : Mask dari frame target setiap baris (`1`) dibandingkan dengan padding (`0`) di `labels`.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** `PocketTTSOutputWithPast` atau `tuple(torch.Tensor)`

Sebuah `PocketTTSOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([PocketTTSConfig](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSConfig)) dan input.

Metode forward dari [PocketTTSForConditionalGeneration](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSForConditionalGeneration) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `()`, *opsional*, dikembalikan ketika `labels` diberikan) -- Loss pelatihan: loss alur LSD dari latens target ditambah `config.eos_loss_weight` kali loss end-of-speech.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 1)`) -- Logits akhir ucapan, satu per posisi.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Hidden states yang ternormalisasi dari backbone, yang menjadi kondisi bagi flow head.

Contoh:

```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/generation_pocket_tts.py#L122)

**Parameter:**

inputs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : `input_ids` yang disiapkan oleh [PocketTTSProcessor](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor). Dapat juga diteruskan sebagai `input_ids=`.

kwargs (`dict[str, Any]`, *opsional*) : `attention_mask`, prompt suara (`audio_prompt_latents` dan `audio_prompt_latents_mask`, atau cache dari prefiks suara sebagai `past_key_values`, suara bawaan, dengan prompt hanya teks), `frames_after_eos` dari prosesor, parameter generasi (`do_sample`, `temperature`, `max_new_tokens`, ...), serta `num_flow_steps`, `eos_threshold`, dan `min_frames_before_eos` yang spesifik untuk Pocket TTS, yang secara default mengikuti konfigurasi generasi.

**Mengembalikan:**

[PocketTTSGenerateOutput](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) ketika `return_dict_in_generate=True` (konfigurasi generasi checkpoint): `audio_latents` yang di-pad beserta `audio_latents_mask` mereka, yang [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) dekode sebagai satu batch. Jika tidak, daftar latens yang dihasilkan, satu tensor `(num_frames, latent_dim)` per sampel, masing-masing didekode secara terpisah.

Menghasilkan ucapan. Metode ini menimpa [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk mengatur nilai default `max_new_tokens` ke anggaran frame runtime asli, yaitu `ceil((num_text_tokens / 3 + 2) * frame_rate)` untuk teks terpanjang dalam batch. Hal lainnya melewati hook generasi reguler.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L807)

**Parameter:**

condition (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) : Hidden state backbone dari posisi yang sedang dihasilkan.

noise (`torch.Tensor` dengan bentuk `(batch_size, latent_dim)`) : derau Gaussian yang diskalakan dengan `sqrt(temperature)`, atau nol.

num_flow_steps (`int`) : Jumlah langkah Euler dari sampler LSD (diabaikan oleh drifting head, yang hanya melakukan satu panggilan).

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, latent_dim)`

laten yang disampelkan, dalam ruang ternormalisasi.

Mengambil sampel laten berikutnya dari `noise` dengan flow head.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L854)

Memetakan latents dari ruang ternormalisasi flow head ke ruang audio tokenizer.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/generation_pocket_tts.py#L40)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : id token prompt diikuti oleh satu `audio_latent_token_id` per frame yang dihasilkan. Audio-nya sendiri ada di `audio_latents`.

scores (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_scores=True`) : Logit end-of-speech untuk setiap frame yang dihasilkan, satu tensor dengan bentuk `(batch_size,)` per frame.

logits (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_logits=True`) : Sama seperti `scores`: Pocket TTS tidak memiliki kosakata, sehingga tidak ada yang perlu diproses di antara keduanya.

attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap frame yang dihasilkan) dari tuple (satu elemen untuk setiap layer) dari `torch.Tensor` dengan bentuk `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_hidden_states=True`) : Tuple (satu elemen untuk setiap frame yang dihasilkan) dari tuple (satu elemen untuk setiap layer) dari `torch.Tensor` dengan bentuk `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opsional*, dikembalikan saat `use_cache=True`) : Kunci/nilai cache dari backbone pada akhir generasi.

audio_latents (`torch.Tensor` dengan bentuk `(batch_size, num_frames, latent_dim)`) : Latent yang dihasilkan, dalam ruang latent audio tokenizer, dengan padding nol di sisi kanan melewati frame milik masing-masing sampel. [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/id/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) mengubahnya menjadi waveform.

audio_latents_mask (`torch.LongTensor` dengan bentuk `(batch_size, num_frames)`) : Mask untuk frame dari setiap sampel (`1`), termasuk frame end-of-speech dan frame setelahnya, berlawanan dengan padding (`0`).

Output dari `PocketTTSForConditionalGeneration.generate`.

