# Pocket TTS

## Tổng quan

Pocket TTS là mô hình chuyển văn bản thành giọng nói 100 triệu tham số của [Kyutai](https://kyutai.org), một [Continuous Audio Language Model](https://huggingface.co/papers/2509.06926) chạy nhanh hơn thời gian thực trên CPU. Một transformer nhân quả phát ra một latent âm thanh liên tục cho mỗi khung hình (12.5 Hz) thông qua một đầu flow một bước, và một đầu kết thúc giọng nói quyết định khi nào cần dừng lại.

Bộ xử lý chứa [tokenizer âm thanh Pocket TTS](./pocket_tts_audio_tokenizer), một codec dựa trên Mimi, mã hóa các prompt giọng nói và giải mã các latent đã tạo thành âm thanh 24 kHz. Các giọng nói định nghĩa sẵn được đóng gói dưới dạng KV cache (`voices/`).

Hai đầu luồng được phát hành: tự chưng cất Lagrangian (`flow_type="lsd"`, mặc định) và trôi dạt (`flow_type="drifting"`, `english_drifting_26-09`). Hỗ trợ tinh chỉnh, xem [Đào tạo](#training).

Mô hình này được đóng góp bởi [Eustache Le Bihan](https://huggingface.co/eustlb). Mã gốc là [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts).

## Mẹo sử dụng

- Chuẩn bị đầu vào bằng [apply_chat_template()](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (mỗi văn bản có một thông điệp `user`, `add_generation_prompt=True`). Bộ chuẩn hóa của tokenizer chuẩn bị văn bản giống như bản gốc, với các cài đặt ngôn ngữ của checkpoint.
- `generate` trả về `audio_latents` và `audio_latents_mask`; giải mã chúng bằng [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- `max_new_tokens` mặc định là một ngân sách dựa trên độ dài văn bản, và quá trình tạo sẽ dừng ngay sau khi logit cuối giọng nói vượt qua `eos_threshold`.
- `do_sample=False` khớp với bản gốc ở nhiệt độ 0. Khi dùng sampling, `temperature` (mặc định 0.3) là phương sai của nhiễu khởi đầu của luồng.
- Tách văn bản dài bằng [PocketTTSProcessor.split_text()](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), mỗi chunk chứa một cuộc hội thoại.

## Cách sử dụng

### Giọng nói

Giọng nói có thể được cung cấp theo ba cách.

**1. Nhân bản bản ghi**: một mục `audio` trong cuộc trò chuyện.

```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. Latents đã tính trước**: một mục `audio` trống, với các latents được truyền vào bộ xử lý.

```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. Bối cảnh được lưu đệm**: bộ đệm KV của lời nhắc giọng nói, được truyền dưới dạng `past_key_values`. Các giọng nói được cung cấp (`voices/`) sử dụng định dạng này.

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

### Các lô và văn bản dài

Đóng gói nhiều văn bản và giọng nói, với văn bản dài được chia thành các phần:

```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 trôi

Cách sử dụng tương tự, với giọng nói của chính checkpoint:

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

## Huấn luyện

Đặt âm thanh đích vào lượt `assistant`. Bộ xử lý trả về các latent của nó dưới dạng `labels`, và mô hình trả về loss của bản gốc (loss luồng LSD cộng với `config.eos_loss_weight` nhân với loss cuối giọng nói). Mẹo giọng nói thường là phần đầu của cùng một câu nói.

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

- Cung cấp giọng nói dưới dạng bản ghi âm hoặc latents, không phải cache.
- Đối với classifier-free guidance, hãy bỏ mục `audio` hoặc `text` của lượt `user` (bản gốc bỏ mỗi mục với xác suất 0.2).
- Các latent đã tính trước được đưa vào `processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`, với các mục `{"type": "audio"}` trống làm vị trí giữ chỗ.
- Công thức gốc: AdamW, `learning_rate=2e-5` (2e-4 cho một ngôn ngữ mới), `adam_beta2=0.95`, `weight_decay=0.1`, `max_grad_norm=1.0`, 1000 bước warmup sau đó giữ hằng, EMA của trọng số (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)
```

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

**Tham số:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *tùy chọn*) : Cấu hình của flow head lấy mẫu mỗi latent từ trạng thái ẩn của backbone.

vocab_size (`int`, *tùy chọn*, mặc định là `4004`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

hidden_size (`int`, *tuỳ chọn*, mặc định là `1024`) : Kích thước của các biểu diễn ẩn.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `6`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `16`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

num_key_value_heads (`int`, *optional*) : Đây là số lượng key_value heads cần được sử dụng để triển khai Grouped Query Attention. Nếu `num_key_value_heads=num_attention_heads`, mô hình sẽ sử dụng Multi Head Attention (MHA), nếu `num_key_value_heads=1` mô hình sẽ sử dụng Multi Query Attention (MQA), ngược lại GQA sẽ được sử dụng. Khi chuyển đổi một checkpoint multi-head sang checkpoint GQA, mỗi nhóm key và value head nên được xây dựng bằng cách meanpooling tất cả các head gốc trong nhóm đó. Để biết thêm chi tiết, hãy xem [bài báo này](https://huggingface.co/papers/2305.13245). Nếu không được chỉ định, giá trị mặc định sẽ là `num_attention_heads`.

head_dim (`int`, *optional*) : Kích thước chiều của đầu chú ý. Nếu là None, giá trị mặc định sẽ là hidden_size // num_attention_heads

intermediate_size (`int`, *tuỳ chọn*, mặc định là `4096`) : Kích thước của các biểu diễn MLP.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu_pytorch_tanh`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

layer_norm_eps (`float`, *optional*, mặc định là 1e-05) : Epsilon của các layer normalization trong backbone.

attention_bias (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng bias trong các lớp chiếu query, key, value và output trong quá trình tự chú ý hay không.

attention_dropout (`float`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `8192`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Từ điển chứa các tham số cấu hình cho các embedding RoPE. Từ điển phải chứa một giá trị cho `rope_theta` và tùy chọn các tham số được sử dụng để mở rộng trong trường hợp bạn muốn sử dụng RoPE với `max_position_embeddings` dài hơn.

latent_dim (`int`, *tuỳ chọn*, mặc định là 32) : Kích thước của các latent âm thanh mà backbone nhận vào đầu vào (`audio_prompt_latents`, `audio_latents`); bằng `latent_dim` của flow head và audio tokenizer.

pad_token_id (`int`, *tuỳ chọn*, mặc định là `3`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

bos_token_id (`int`, *tùy chọn*) : Id của token được sử dụng cho đầu luồng trong bảng từ vựng.

eos_token_id (`int`, *tuỳ chọn*) : Id của token được sử dụng cho dấu kết thúc luồng trong từ vựng.

audio_prompt_token_id (`int`, *tuỳ chọn*, mặc định là 4000) : id của token placeholder cho các khung voice-prompt trong `input_ids`.

audio_latent_token_id (`int`, *tuỳ chọn*, mặc định là 4001) : id của token placeholder cho các vị trí latent của âm thanh trong `input_ids`.

audio_prompt_bos_token_id (`int`, *optional*, mặc định là 4002) : Token id được đặt trước voice prompt; embedding của nó là vector đã học mà bản gốc thêm vào trước voice.

audio_bos_token_id (`int`, *optional*, mặc định là 4003) : Token id của vị trí âm thanh đầu tiên, đóng lại prompt: nó chứa latent BOS đã học, từ đó khung đầu tiên được tạo ra.

frame_rate (`float`, *optional*, mặc định là 12.5) : Số lượng audio latents trên mỗi giây âm thanh: `generate` suy ra ngân sách khung hình mặc định từ giá trị này.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

use_cache (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có nên trả về các chú ý key/values cuối cùng hay không (không được sử dụng bởi tất cả các mô hình). Chỉ liên quan nếu `config.is_decoder=True` hoặc khi mô hình là mô hình sinh chỉ có decoder.

eos_loss_weight (`float`, *tuỳ chọn*, mặc định là 0.1) : Trọng số của loss kết thúc giọng nói trong loss huấn luyện.

flow_loss_num_samples (`int`, *optional*, mặc định là 4) : Số lần lấy mẫu nhiễu cho mỗi khung hình đích trong tổn thất dòng chảy.

lsd_distill_probability (`float`, *optional*, mặc định là 0.25) : Xác suất, tại mỗi bước huấn luyện, để tính toán thành phần tự phân phối (self-distillation) của tổn thất LSD (được tái trọng số hóa để giữ nguyên tổn thất kỳ vọng); giá trị 1 sẽ tính toán nó ở mọi bước.

lsd_diagonal_weight (`float`, *optional*, mặc định là 0.75) : Trọng số của số hạng đường chéo (dòng tức thời) của tổn thất LSD; số hạng tự chưng cất sẽ gán trọng số cho phần còn lại.

lsd_time_logit_mean (`float`, *optional*, mặc định là 0.4) : Trung bình của phân phối logit-normal của các thời điểm dòng chảy được rút ra bởi tổn thất LSD.

lsd_time_logit_std (`float`, *optional*, mặc định là 1.0) : Độ lệch chuẩn của phân phối logit-normal của các thời điểm luồng được rút ra bởi tổn thất LSD.

latent_stats_ema_steps (`int`, *optional*, mặc định là 1000) : Số bước huấn luyện đầu tiên mà trong đó `latent_mean` và `latent_std` tuân theo trung bình trượt mũ (exponential moving average) của các latent đích; 0 giữ chúng ở trạng thái đóng băng.

latent_stats_ema_decay (`float`, *tuỳ chọn*, mặc định là 0.999) : Hệ số suy giảm của trung bình trượt đó.

Đây là lớp cấu hình để lưu trữ cấu hình của một PocketTTSModel. Nó được sử dụng để khởi tạo một mô hình Pocket Tts theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `512`) : Kích thước của các biểu diễn ẩn.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `6`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

latent_dim (`int`, *optional*, mặc định là 32) : Kích thước của các latent âm thanh liên tục mà head dự đoán (kích thước latent của audio tokenizer).

condition_dim (`int`, *optional*, mặc định là 1024) : Kích thước của trạng thái ẩn của backbone mà head được điều kiện trên đó (kích thước ẩn `hidden_size` của backbone).

frequency_embedding_size (`int`, *tuỳ chọn*, mặc định là 256) : Kích thước của nhúng hình sin của thời điểm luồng.

hidden_act (`str`, *tùy chọn*, mặc định là `silu`) : Hàm kích hoạt phi tuyến tính (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là 1e-06) : Epsilon của các lớp chuẩn hóa (layer normalization) bên trong các khối dư (residual blocks) và lớp cuối cùng.

rms_norm_eps (`float`, *optional*, mặc định là 1e-05) : Epsilon của phép chuẩn hóa đóng các nhúng thời gian.

max_period (`float`, *optional*, mặc định là 10000.0) : Chu kỳ tối đa của nhúng thời gian hình sin, được checkpoint lưu dưới dạng `freqs`.

flow_type (`str`, *tùy chọn*, mặc định là `"lsd"`) : Mục tiêu mà đầu (head) được huấn luyện với, quyết định cách nó được điều kiện hóa và lấy mẫu. `"lsd"` (tự chưng cất Lagrangian): được điều kiện hóa theo thời điểm bắt đầu và kết thúc của một bước flow, lấy mẫu bằng các bước Euler từ nhiễu Gaussian. `"drifting"`: không có điều kiện hóa theo thời gian, đầu ánh xạ nhiễu sang latent trong một lần gọi.

loss_weighting_hidden_size (`int`, *tuỳ chọn*, mặc định là 32) : Độ rộng của MLP học trọng số bất định của các số hạng tổn thất LSD từ thời gian dòng chảy của chúng (chỉ dùng cho huấn luyện).

loss_weighting_num_layers (`int`, *tuỳ chọn*, mặc định là 3) : Số lượng lớp ẩn của MLP đó.

Đây là lớp cấu hình để lưu trữ cấu hình của một PocketTTSModel. Nó được sử dụng để khởi tạo một mô hình Pocket Tts theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

feature_size (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng kênh.

sampling_rate (`int`, *optional*, mặc định là 24000) : Tần số lấy mẫu mà tại đó dạng sóng âm thanh cần được số hóa, được biểu diễn bằng hertz (Hz).

padding_value (`float`, *tuỳ chọn*, mặc định là 0.0) : Giá trị được sử dụng để đệm.

frame_size (`int`, *tuỳ chọn*, mặc định là 1920) : Số lượng mẫu âm thanh trên mỗi khung tiềm ẩn của bộ mã hóa âm thanh (tức là `frame_size` của nó).

pad_to_multiple_of (`int`, *optional*, mặc định là 1920) : Lấp đầy âm thanh đến bội số của giá trị này; bội số của `frame_size` giữ nguyên vẹn mọi khung latent.

end_on_pause (`bool`, *tùy chọn*, mặc định là `True`) : Có kết thúc mỗi waveform bằng đúng `pause_duration` giây im lặng hay không: phần im lặng ở cuối (các khung dài hơn `analysis_frame_duration` giây và thấp hơn `silence_floor_db` so với khung to nhất) sẽ bị cắt bỏ, `fade_out_duration` giây cuối cùng của phần còn lại sẽ được fade out, và `pause_duration` giây số 0 sẽ được thêm vào.

pause_duration (`float`, *optional*, mặc định là 0.08) : Thời lượng của khoảng im lặng được thêm vào bởi `end_on_pause`, tính bằng giây.

fade_out_duration (`float`, *optional*, mặc định là 0.02) : Thời lượng của hiệu ứng mờ dần do `end_on_pause` áp dụng trước khi tạm dừng, tính bằng giây.

silence_floor_db (`float`, *optional*, mặc định là 35.0) : Mức dưới khung phân tích to nhất, tính bằng dB, mà dưới mức đó `end_on_pause` coi các khung cuối là im lặng.

analysis_frame_duration (`float`, *optional*, mặc định là 0.02) : Thời lượng của các khung hình mà `end_on_pause` đo mức độ, tính bằng giây.

Tạo một bộ trích xuất đặc trưng Pocket TTS, có chức năng chuẩn bị các dạng sóng lời nhắc giọng nói cho bộ mã hóa của bộ mã hóa âm thanh.

Mỗi dạng sóng tùy chọn kết thúc bằng một khoảng nghỉ ngắn (tương ứng với `end_on_pause` của bản gốc: các prompt huấn luyện kết thúc bên trong khoảng nghỉ giữa hai từ, một prompt dừng ở giọng nói sẽ khiến mô hình tiếp tục nó và một prompt kết thúc bằng khoảng im lặng dài sẽ làm trì hoãn sự khởi đầu), sau đó batch được đệm bên phải đến bội số của kích thước khung của 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)
```

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

**Tham số:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Dạng sóng đơn hoặc lô các dạng sóng đơn của các lời nhắc giọng nói.

sampling_rate (`int`, *optional*) : Tần số lấy mẫu mà đầu vào `audio` được lấy mẫu. Rất khuyến nghị truyền `sampling_rate` tại cuộc gọi forward để ngăn các lỗi âm thầm.

end_on_pause (`bool`, *tùy chọn*) : Có kết thúc mỗi dạng sóng bằng một khoảng nghỉ ngắn hay không, xem docstring của lớp. Mặc định là `self.end_on_pause`.

padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tuỳ chọn*, mặc định là `True`) : Chiến lược đệm của batch, xem [pad()](/docs/transformers/v5.23.0/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

pad_to_multiple_of (`int`, *optional*) : Lấp đầy batch thành bội số của giá trị này. Mặc định là `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)
```

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

**Tham số:**

feature_extractor (`PocketTTSFeatureExtractor`) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

tokenizer (`TokenizersBackend`) : Tokenizer là đầu vào bắt buộc.

audio_tokenizer (`PocketTTSAudioTokenizerModel`, *tùy chọn*) : Bộ mã hóa: mã hóa âm thanh thành các biến ẩn (latents) và giải mã các biến ẩn đã tạo thành âm thanh.

chat_template (`str`) : Một mẫu Jinja để chuyển đổi các danh sách tin nhắn trong một cuộc trò chuyện thành chuỗi có thể token hóa.

short_text_max_words (`int`, *tuỳ chọn*, mặc định là 4) : Các văn bản có tối đa số từ này sẽ nhận được `frames_after_eos_short_text` khung sau khung kết thúc giọng nói.

frames_after_eos_short_text (`int`, *tuỳ chọn*, mặc định là 4) : Số khung hình được tạo ra sau khung hình kết thúc giọng nói đối với các văn bản ngắn.

frames_after_eos (`int`, *tuỳ chọn*, mặc định là 2) : Số khung hình được tạo ra sau khung hình kết thúc giọng nói cho các văn bản dài hơn.

fade_in_duration (`float`, *optional*, mặc định là 0.005) : Thời lượng tính bằng giây của hiệu ứng fade-in tuyến tính được áp dụng vào phần đầu của mỗi waveform đã giải mã: một trạng thái decoder mới bắt đầu với một bước nhỏ, nghe như một tiếng click.

Tạo một PocketTTSProcessor đóng gói một bộ trích xuất đặc trưng và một bộ phân từ thành một bộ xử lý duy nhất.

[PocketTTSProcessor](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor) cung cấp đầy đủ các chức năng của [PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) và [TokenizersBackend](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.TokenizersBackend). Xem [~PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) và [~TokenizersBackend](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.TokenizersBackend) để biết thêm thông tin.

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

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

**Tham số:**

text (`str` hoặc `list[str]`) : Prompt được render bởi [apply_chat_template()](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

audio (`np.ndarray`, `torch.Tensor`, hoặc một danh sách của chúng, *không bắt buộc*) : Các dạng sóng của các cuộc hội thoại, đơn âm ở 24 kHz, theo thứ tự cuộc hội thoại: mỗi giọng nói, và trong huấn luyện là mỗi mục tiêu.

audio_prompt_latents (`list[torch.Tensor]`, *tùy chọn*) : Các giọng nói đã tính toán trước, mỗi placeholder giọng nói có một tensor `(num_frames, latent_dim)`, thay vì dạng sóng.

labels (`list[torch.Tensor]`, *tùy chọn*) : Các mục tiêu đã tính trước (đào tạo), mỗi vị trí giữ chỗ cho mục tiêu tương ứng với một tensor `(num_frames, latent_dim)`, thay vì dạng sóng.

end_on_pause (`bool`, *kwargs*, *optional*) : Xác định có kết thúc mỗi waveform voice-prompt bằng một khoảng nghỉ ngắn hay không, giống như cách bản gốc thực hiện trước khi nhân bản giọng nói. Mặc định là `end_on_pause` của feature extractor.

return_mm_token_type_ids (`bool`, *kwargs*) : Có nên trả về các id loại token đa phương thức chỉ định vị trí của các token placeholder đa phương thức hay không.

return_text_replacement_offsets (`bool`, *kwargs*) : Có nên trả về các vị trí ký tự cho mỗi placeholder đa phương thức và phần thay thế của nó hay không.

return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

**Trả về:**

[BatchFeature](/docs/transformers/v5.23.0/vi/main_classes/feature_extractor#transformers.BatchFeature) với `input_ids`, `attention_mask`, `audio_prompt_latents` và `audio_prompt_latents_mask`; cho quá trình sinh là `frames_after_eos` (các khung được sinh sau khung kết thúc giọng nói, theo độ dài văn bản), cho quá trình huấn luyện là `labels` và `labels_mask`.

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

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

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

**Tham số:**

text (`str`) : Văn bản cần tách.

max_tokens (`int`, *tùy chọn*, mặc định là 50) : Số lượng token tối đa cho mỗi chunk.

Tách `text` thành các đoạn văn bản căn chỉnh theo câu, mỗi đoạn tối đa `max_tokens` token, giống như `split_into_best_sentences` của bản gốc: văn bản đã được chuẩn bị sẽ được cắt sau dấu kết thúc câu (không cắt tại dấu chấm thập phân), các câu dài hơn `max_tokens` sẽ được cắt sau dấu kết thúc mệnh đề, và các phần sẽ được nhóm lại theo cách tham lam. Mỗi đoạn được thiết kế để là một cuộc hội thoại trong một lô.

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

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

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

**Tham số:**

audio_latents (`torch.Tensor` có shape `(batch_size, num_frames, latent_dim)` hoặc `(num_frames, latent_dim)`) : Các latents mà `generate` trả về (`PocketTTSGenerateOutput.audio_latents`), được giải mã như một batch, hoặc latents của một mẫu.

audio_latents_mask (`torch.Tensor` có shape `(batch_size, num_frames)`, *tùy chọn*) : Mask của các frame trong mỗi mẫu (`PocketTTSGenerateOutput.audio_latents_mask`). Nếu không có mask này, mỗi hàng sẽ được giải mã ở độ dài đầy đủ.

**Trả về:**

`list[torch.Tensor]` chứa các waveform 1D trên CPU, một waveform cho mỗi hàng, hoặc một waveform cho latents của một mẫu.

Giải mã các latent đã tạo thành dạng sóng bằng audio tokenizer, và làm mờ dần `fade_in_duration` giây đầu tiên của mỗi âm thanh, giống như bản gốc.

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

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

Viết các dạng sóng đã tạo vào tệp WAV.

audio (`torch.Tensor`, `np.ndarray` hoặc một danh sách của chúng): Dạng sóng, như được trả về bởi [decode()](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode). saving_path (`str`, `Path` hoặc một danh sách của chúng): Một đường dẫn cho mỗi dạng sóng. sampling_rate (`int`, *optional*): Tần số lấy mẫu của các dạng sóng, mặc định là của bộ trích xuất đặc trưng (bộ mã hóa âm thanh).

## PocketTTSModel[[transformers.PocketTTSModel]]

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

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

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

**Tham số:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Xương sống Pocket TTS: một transformer nhân quả trên một luồng duy nhất gồm voice prompt, các text token và các audio latents, trả về các hidden states đã được chuẩn hóa. Voice prompt và các audio latents là các latents của audio tokenizer, được giữ bởi processor.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` có shape `(batch_size, num_prompt_frames, latent_dim)`, *tùy chọn*) : Latents của voice-prompt từ audio tokenizer (được mã hóa bởi processor, hoặc từ `voices/` của một checkpoint), được right-pad đến voice dài nhất trong batch, và phân tán vào các vị trí `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` có shape `(batch_size, num_prompt_frames)`, *tùy chọn*) : Mặt nạ của các khung âm thanh (`1`) so với padding (`0`) trong `audio_prompt_latents`.

audio_latents (`torch.Tensor` có shape `(batch_size, num_latents, latent_dim)`, *tùy chọn*) : Các audio latents đã chuẩn hóa, được phân tán vào các vị trí `audio_latent_token_id`. Vị trí `audio_bos_token_id` nằm trước chúng, đóng vai trò kết thúc prompt và là nơi khung đầu tiên được tạo ra, luôn nhận latent BOS đã học.

audio_latents_mask (`torch.Tensor` có shape `(batch_size, num_latents)`, *tùy chọn*) : Mask của các latents trong mỗi hàng (`1`) so với padding (`0`) trong `audio_latents`, khi các hàng chứa số lượng vị trí latent khác nhau (đào tạo).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

**Trả về:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutputWithPast](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([PocketTTSConfig](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSConfig)) và đầu vào.

Phương thức forward của [PocketTTSModel](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.

  Nếu `past_key_values` được sử dụng, chỉ có hidden-state cuối cùng của các chuỗi có shape `(batch_size, 1, hidden_size)` được xuất ra.
- **past_key_values** (`Cache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và tùy chọn nếu `config.is_encoder_decoder=True` trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

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

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

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

**Tham số:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình text-to-speech Pocket TTS: phần lõi, đầu flow lấy mẫu một ẩn âm thanh mỗi bước và đầu kết thúc giọng nói. Nó tạo ra các ẩn của bộ mã hóa âm thanh, sau đó bộ xử lý giải mã chúng thành âm thanh 24 kHz.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` có shape `(batch_size, num_prompt_frames, latent_dim)`, *tùy chọn*) : Các latent của voice-prompt từ audio tokenizer, được right-padded và phân tán vào các vị trí `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` có shape `(batch_size, num_prompt_frames)`, *tùy chọn*) : Mặt nạ của các khung âm thanh (`1`) so với padding (`0`) trong `audio_prompt_latents`.

audio_latents (`torch.Tensor` có shape `(batch_size, num_latents, latent_dim)`, *tùy chọn*) : Các audio latents đã chuẩn hóa, được phân tán vào các vị trí `audio_latent_token_id`.

labels (`torch.Tensor` có shape `(batch_size, num_frames, latent_dim)`, *tùy chọn*) : Target latents của audio tokenizer (training), được right-padded. Prompt của mỗi dòng kết thúc bằng vị trí `audio_bos_token_id` tiếp theo là một vị trí `audio_latent_token_id` cho mỗi frame: mô hình đưa các target đã chuẩn hóa (teacher forcing), áp dụng flow loss lên outputs của BOS và tất cả các frame trừ frame cuối, những frame này dự đoán các frame, và áp dụng end-of-speech loss lên tất cả chúng, trong đó frame cuối là end of speech.

labels_mask (`torch.Tensor` có shape `(batch_size, num_frames)`, *tùy chọn*) : Mask của các khung hình đích (`1`) so với padding (`0`) trong `labels` của mỗi hàng.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

**Trả về:** `PocketTTSOutputWithPast` hoặc `tuple(torch.Tensor)`

Một `PocketTTSOutputWithPast` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([PocketTTSConfig](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSConfig)) và đầu vào.

Phương thức forward của [PocketTTSForConditionalGeneration](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSForConditionalGeneration) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `()`, *optional*, được trả về khi truyền `labels`) -- Loss huấn luyện: loss luồng LSD của các latents đích cộng với `config.eos_loss_weight` nhân với loss end-of-speech.
- **logits** (`torch.Tensor` có shape `(batch_size, sequence_length, 1)`) -- Logits kết thúc giọng nói, một giá trị cho mỗi vị trí.
- **past_key_values** (`Cache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Trạng thái ẩn đã chuẩn hóa của backbone, đóng vai trò điều kiện cho flow head.

Ví dụ:

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

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

**Tham số:**

inputs (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : `input_ids` được chuẩn bị bởi [PocketTTSProcessor](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor). Cũng có thể được truyền dưới dạng `input_ids=`.

kwargs (`dict[str, Any]`, *tùy chọn*) : `attention_mask`, prompt giọng nói (`audio_prompt_latents` và `audio_prompt_latents_mask`, hoặc cache của tiền tố giọng nói dưới dạng `past_key_values`, các giọng nói có sẵn, với prompt chỉ gồm văn bản), `frames_after_eos` từ bộ xử lý, các tham số sinh (`do_sample`, `temperature`, `max_new_tokens`, ...), và `num_flow_steps`, `eos_threshold` cùng `min_frames_before_eos` đặc thù của Pocket TTS, mặc định lấy từ cấu hình sinh.

**Trả về:**

[PocketTTSGenerateOutput](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) khi `return_dict_in_generate=True` (cấu hình sinh của các checkpoint): `audio_latents` đã được đệm và `audio_latents_mask` tương ứng, được [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) giải mã như một lô. Ngược lại, danh sách các latent đã sinh, mỗi mẫu là một tensor `(num_frames, latent_dim)`, mỗi tensor được giải mã riêng lẻ.

Tạo giọng nói. Phương thức này ghi đè [generate()](/docs/transformers/v5.23.0/vi/main_classes/text_generation#transformers.GenerationMixin.generate) để mặc định `max_new_tokens` thành ngân sách khung của thời gian chạy gốc, `ceil((num_text_tokens / 3 + 2) * frame_rate)` cho văn bản dài nhất trong lô. Mọi thứ khác đều đi qua các hook tạo thông thường.

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

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

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

**Tham số:**

condition (`torch.Tensor` có shape `(batch_size, hidden_size)`) : Trạng thái ẩn (hidden state) của backbone tại vị trí đang được sinh ra.

noise (`torch.Tensor` có hình dạng `(batch_size, latent_dim)`) : nhiễu Gaussian được nhân với `sqrt(temperature)`, hoặc các số 0.

num_flow_steps (`int`) : Số bước Euler của bộ lấy mẫu LSD (bị bỏ qua bởi đầu trôi, chỉ thực hiện một lần gọi).

**Trả về:** `torch.Tensor` có hình dạng `(batch_size, latent_dim)`

latent được lấy mẫu, trong không gian đã chuẩn hóa.

Mẫu latent tiếp theo từ `noise` bằng flow head.

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

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

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

Ánh xạ các biến ẩn từ không gian đã chuẩn hóa của đầu luồng sang không gian của bộ mã hóa âm thanh.

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

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

**Tham số:**

sequences (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Các id token của prompt, tiếp theo là một `audio_latent_token_id` cho mỗi khung được tạo ra. Bản thân âm thanh nằm trong `audio_latents`.

scores (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_scores=True`) : Logit end-of-speech của mỗi khung hình được tạo ra, một tensor có hình dạng `(batch_size,)` cho mỗi khung hình.

logits (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_logits=True`) : Giống như `scores`: Pocket TTS không có bảng từ vựng, nên không có gì cần xử lý giữa hai phần này.

attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi khung hình được tạo) của các tuple (một phần tử cho mỗi lớp) của `torch.Tensor` có hình dạng `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Tuple (một phần tử cho mỗi khung hình được tạo) của các tuple (một phần tử cho mỗi lớp) của `torch.Tensor` có hình dạng `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *tùy chọn*, được trả về khi `use_cache=True`) : Bộ nhớ đệm key/value của backbone tại thời điểm kết thúc quá trình sinh.

audio_latents (`torch.Tensor` có shape `(batch_size, num_frames, latent_dim)`) : Các latent được tạo ra, trong không gian latent của audio tokenizer, được right-pad bằng số 0 vượt quá số frames của từng mẫu. [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/vi/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) chuyển chúng thành waveform.

audio_latents_mask (`torch.LongTensor` có hình dạng `(batch_size, num_frames)`) : Mặt nạ của các khung hình cho mỗi mẫu (`1`), bao gồm khung hình kết thúc giọng nói và các khung hình sau đó, trái ngược với phần đệm (`0`).

Đầu ra của `PocketTTSForConditionalGeneration.generate`.

