# Pocket TTS

## Обзор

Pocket TTS — это модель преобразования текста в речь от [Kyutai](https://kyutai.org) с 100 млн параметров, являющаяся [Continuous Audio Language Model](https://huggingface.co/papers/2509.06926), которая работает быстрее реального времени на CPU. Причинный трансформер генерирует один непрерывный аудиолатентный вектор на кадр (12,5 Гц) через одношаговую flow-головку, а головка конца речи определяет момент остановки.

Процессор содержит [аудиотокенизатор Pocket TTS](./pocket_tts_audio_tokenizer) — кодек на основе Mimi, который кодирует голосовые подсказки и декодирует сгенерированные латенты в аудио с частотой 24 кГц. Предопределённые голоса поставляются в виде KV-кэшей (`voices/`).

Опубликованы два flow heads: Lagrangian self-distillation (`flow_type="lsd"`, по умолчанию) и drifting (`flow_type="drifting"`, `english_drifting_26-09`). Поддерживается дообучение, см. [Обучение](#training).

Эта модель была предоставлена [Eustache Le Bihan](https://huggingface.co/eustlb). Исходный код — [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts).

## Советы по использованию

- Подготовьте входные данные с помощью [apply_chat_template()](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (одно сообщение `user` на каждый текст, `add_generation_prompt=True`). Нормализатор токенизатора готовит текст так же, как и в оригинале, с настройками языка чекпоинта.
- `generate` возвращает `audio_latents` и `audio_latents_mask`; декодируйте их с помощью [PocketTTSProcessor.decode()](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- `max_new_tokens` по умолчанию устанавливается в соответствии с бюджетом, основанным на длине текста, а генерация останавливается вскоре после того, как логит конца речи превысит `eos_threshold`.
- `do_sample=False` соответствует исходному при температуре 0. При сэмплировании `temperature` (по умолчанию 0.3) — это дисперсия начального шума потока.
- Разбейте длинный текст с помощью [PocketTTSProcessor.split_text()](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), размещая один диалог в каждом фрагменте.

## Использование

### Голос

Голос можно задать тремя способами.

**1. Клонирование записи**: элемент `audio` в разговоре.

```python
from transformers import AutoModelForTextToWaveform, AutoProcessor

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

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

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

**2. Предвычисленные латенты**: пустой элемент `audio`, при этом латенты передаются в процессор.

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

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

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

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

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

**3. Кэшированный контекст**: кэш KV голосового промпта, передаваемый как `past_key_values`. В поставленных голосах (`voices/`) используется именно эта форма.

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

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

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

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

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

### Пакеты и длинный текст

Пакетная обработка нескольких текстов и голосов, при этом длинный текст разбивается на фрагменты:

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

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

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

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

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

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

### Дрейф контрольной точки

Тот же способ использования, но с собственными голосами контрольной точки:

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

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

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

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

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

## Обучение

Поместите целевой аудио в ход `assistant`. Процессор возвращает его латенты в качестве `labels`, а модель возвращает потерю оригинала (потеря потока LSD плюс `config.eos_loss_weight`, умноженное на потерю конца речи). Голосовой промпт обычно представляет собой начало того же высказывания.

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

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

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

- Передавайте голос в виде записи или латентов, а не кэша.
- Для classifier-free guidance удалите элемент `audio` или `text` из хода `user` (в оригинале каждый удаляется с вероятностью 0.2).
- Предвычисленные латенты передаются в `processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`, при этом в качестве заполнителей используются пустые элементы `{"type": "audio"}`.
- Исходный рецепт: AdamW, `learning_rate=2e-5` (2e-4 для нового языка), `adam_beta2=0.95`, `weight_decay=0.1`, `max_grad_norm=1.0`, 1000 шагов разгона, затем постоянное значение, EMA весов (затухание 0.999).

## PocketTTSConfig[[transformers.PocketTTSConfig]]

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

```python
transformers.PocketTTSConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, flow_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocab_size: int = 4004, hidden_size: int = 1024, num_hidden_layers: int = 6, num_attention_heads: int = 16, num_key_value_heads: int | None = None, head_dim: int | None = None, intermediate_size: int = 4096, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-05, attention_bias: bool = False, attention_dropout: float = 0.0, max_position_embeddings: int = 8192, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, latent_dim: int = 32, pad_token_id: int = 3, bos_token_id: int | None = None, eos_token_id: int | None = None, audio_prompt_token_id: int = 4000, audio_latent_token_id: int = 4001, audio_prompt_bos_token_id: int = 4002, audio_bos_token_id: int = 4003, frame_rate: float = 12.5, initializer_range: float = 0.02, use_cache: bool = True, eos_loss_weight: float = 0.1, flow_loss_num_samples: int = 4, lsd_distill_probability: float = 0.25, lsd_diagonal_weight: float = 0.75, lsd_time_logit_mean: float = 0.4, lsd_time_logit_std: float = 1.0, latent_stats_ema_steps: int = 1000, latent_stats_ema_decay: float = 0.999)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L75)

**Параметры:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *необязательный*) : Конфигурация flow head, которая сэмплирует каждый латент из скрытого состояния backbone.

vocab_size (`int`, *необязательный*, по умолчанию `4004`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

hidden_size (`int`, *необязательный*, по умолчанию `1024`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `6`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `16`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

num_key_value_heads (`int`, *optional*) : Это количество ключевых и value-голов, которое следует использовать для реализации Grouped Query Attention. Если `num_key_value_heads=num_attention_heads`, модель будет использовать Multi Head Attention (MHA), если `num_key_value_heads=1` — Multi Query Attention (MQA), в противном случае используется GQA. При конвертации multi-head checkpoint в GQA checkpoint каждая группа ключевых и value-голов должна быть построена путем усреднения (meanpooling) всех исходных голов в этой группе. Подробнее см. в [этой статье](https://huggingface.co/papers/2305.13245). Если значение не указано, по умолчанию используется `num_attention_heads`.

head_dim (`int`, *optional*) : Размер измерения внимания. Если None, по умолчанию будет использовано hidden_size // num_attention_heads

intermediate_size (`int`, *необязательный*, по умолчанию `4096`) : Размерность представлений MLP.

hidden_act (`str`, *необязательный*, по умолчанию `gelu_pytorch_tanh`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

layer_norm_eps (`float`, *optional*, по умолчанию 1e-05) : Epsilon для слоёв нормализации в backbone.

attention_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

attention_dropout (`float`, *необязательный*, по умолчанию `0.0`) : Доля dropout для вероятностей внимания.

max_position_embeddings (`int`, *необязательный*, по умолчанию `8192`) : Максимальная длина последовательности, с которой может использоваться данная модель.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`.

latent_dim (`int`, *optional*, по умолчанию 32) : Размерность аудиолатентов, которые принимает базовая модель на вход (`audio_prompt_latents`, `audio_latents`); равно значению `latent_dim` у flow head и аудиотокенизатора.

pad_token_id (`int`, *необязательный*, по умолчанию `3`) : Идентификатор токена, используемый для выравнивания в словаре.

bos_token_id (`int`, *optional*) : Идентификатор токена, используемый для обозначения начала потока в словаре.

eos_token_id (`int`, *необязательный*) : Идентификатор токена, используемый для обозначения конца потока в словаре.

audio_prompt_token_id (`int`, *необязательный*, по умолчанию 4000) : Идентификатор плейсхолдер-токена для кадров голосового промпта в `input_ids`.

audio_latent_token_id (`int`, *optional*, по умолчанию 4001) : Идентификатор токена-заглушки для позиций аудиолатентов в `input_ids`.

audio_prompt_bos_token_id (`int`, *optional*, по умолчанию 4002) : Идентификатор токена, размещаемого перед голосовым промптом; его эмбеддинг представляет собой обученный вектор, который оригинальная модель добавляет перед голосом.

audio_bos_token_id (`int`, *optional*, по умолчанию 4003) : Идентификатор токена первой аудиопозиции, закрывающей промпт: содержит обученный латентный BOS, из которого генерируется первый кадр.

frame_rate (`float`, *optional*, по умолчанию 12.5) : Количество аудиолатентов на секунду аудио: `generate` выводит из него значение бюджета по умолчанию для кадров.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером.

eos_loss_weight (`float`, *необязательный*, по умолчанию 0.1) : Вес потери конца речи в общей функции потерь при обучении.

flow_loss_num_samples (`int`, *optional*, по умолчанию 4) : Количество выборов шума на целевой кадр в потере потока.

lsd_distill_probability (`float`, *optional*, по умолчанию 0.25) : Вероятность вычисления члена самодистилляции в функции потерь LSD на каждом шаге обучения (с пересчетом весов для сохранения ожидаемого значения потери); значение 1 означает вычисление на каждом шаге.

lsd_diagonal_weight (`float`, *optional*, по умолчанию 0.75) : Вес диагонального (мгновенного потока) члена функции потерь LSD; член самодистилляции взвешивает остальную часть.

lsd_time_logit_mean (`float`, *optional*, по умолчанию 0.4) : Среднее значение логит-нормального распределения времен потока, извлекаемых потерей LSD.

lsd_time_logit_std (`float`, *optional*, по умолчанию 1.0) : Стандартное отклонение логит-нормального распределения времен потока, извлекаемых потерей LSD.

latent_stats_ema_steps (`int`, *optional*, по умолчанию 1000) : Количество первых шагов обучения, в течение которых `latent_mean` и `latent_std` следуют за экспоненциальным скользящим средним целевых латентов; 0 оставляет их замороженными.

latent_stats_ema_decay (`float`, *необязательный*, по умолчанию 0.999) : Коэффициент затухания для скользящего среднего.

Это класс конфигурации для хранения настроек модели PocketTTSModel. Он используется для создания модели Pocket Tts в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

## PocketTTSFlowHeadConfig[[transformers.PocketTTSFlowHeadConfig]]

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

```python
transformers.PocketTTSFlowHeadConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 512, num_hidden_layers: int = 6, latent_dim: int = 32, condition_dim: int = 1024, frequency_embedding_size: int = 256, hidden_act: str = 'silu', layer_norm_eps: float = 1e-06, rms_norm_eps: float = 1e-05, max_period: float = 10000.0, flow_type: typing.Literal['lsd', 'drifting'] = 'lsd', loss_weighting_hidden_size: int = 32, loss_weighting_num_layers: int = 3)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L27)

**Параметры:**

hidden_size (`int`, *необязательный*, по умолчанию `512`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `6`) : Количество скрытых слоев в декодере Transformer.

latent_dim (`int`, *optional*, по умолчанию 32) : Размерность непрерывных аудиолатентов, которые предсказывает head (размерность латентов аудиотокенизатора).

condition_dim (`int`, *optional*, по умолчанию 1024) : Размерность скрытого состояния бэкбона, на которое опирается head (`hidden_size` бэкбона).

frequency_embedding_size (`int`, *optional*, по умолчанию 256) : Размер синусоидального эмбеддинга временных шагов потока.

hidden_act (`str`, *необязательный*, по умолчанию `silu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

layer_norm_eps (`float`, *optional*, по умолчанию 1e-06) : Эпсилон для нормализации слоев внутри остаточных блоков и последнего слоя.

rms_norm_eps (`float`, *optional*, по умолчанию 1e-05) : Эпсилон нормализации, завершающей временные эмбеддинги.

max_period (`float`, *optional*, по умолчанию 10000.0) : Максимальный период синусоидального временного эмбеддинга, который чекпоинт сохраняет как `freqs`.

flow_type (`str`, *optional*, по умолчанию `"lsd"`) : Цель, с которой обучалась головка, определяющая способ её обусловливания и выборки. `"lsd"` (лагранжева самодистилляция): обусловливается начальным и конечным временами шага потока, выборка выполняется шагами Эйлера из гауссова шума. `"drifting"`: обусловливание по времени отсутствует, головка отображает шум в латентное пространство за один вызов.

loss_weighting_hidden_size (`int`, *optional*, по умолчанию 32) : Ширина MLP, обучающей веса неопределённости для членов потерь LSD на основе их временных потоков (только для обучения).

loss_weighting_num_layers (`int`, *необязательный*, по умолчанию 3) : Количество скрытых слоёв данного MLP.

Это класс конфигурации для хранения настроек модели PocketTTSModel. Он используется для создания модели Pocket Tts в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

## PocketTTSFeatureExtractor[[transformers.PocketTTSFeatureExtractor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L29)

**Параметры:**

feature_size (`int`, *необязательный*, по умолчанию 1) : Количество каналов.

sampling_rate (`int`, *optional*, по умолчанию 24000) : Частота дискретизации, с которой аудиоволна должна быть оцифрована, выраженная в герцах (Гц).

padding_value (`float`, *необязательный*, по умолчанию 0.0) : Значение, используемое для дополнения (padding).

frame_size (`int`, *optional*, по умолчанию 1920) : Количество аудиовыборок на латентный кадр аудиотокенизатора (его `frame_size`).

pad_to_multiple_of (`int`, *optional*, по умолчанию 1920) : Дополнить аудио до кратного этому значению; кратное `frame_size` сохраняет каждую латентную рамку целой.

end_on_pause (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли завершать каждую звуковую форму ровно `pause_duration` секундами тишины: хвостовая тишина (кадры длительностью `analysis_frame_duration` секунды, громкость которых ниже самой громкой на `silence_floor_db`) отбрасывается, последние `fade_out_duration` секунд оставшейся части плавно затухают, а затем добавляются `pause_duration` секунд нулей.

pause_duration (`float`, *необязательный*, по умолчанию 0.08) : Длительность тишины, добавляемой `end_on_pause`, в секундах.

fade_out_duration (`float`, *optional*, по умолчанию 0.02) : Длительность затухания, применяемого `end_on_pause` перед паузой, в секундах.

silence_floor_db (`float`, *optional*, по умолчанию 35.0) : Уровень в дБ ниже самой громкой анализируемой рамки, ниже которого `end_on_pause` рассматривает хвостовые рамки как тишину.

analysis_frame_duration (`float`, *optional*, по умолчанию 0.02) : Длительность в секундах интервала, уровень которого измеряет `end_on_pause`.

Создаёт экстрактор признаков Pocket TTS, который подготавливает волновые формы голосовых подсказок для кодировщика аудиотокенизатора.

Каждая волна опционально завершается короткой паузой (исходный параметр `end_on_pause`: обучающие промпты заканчиваются внутри паузы между двумя словами, промпт, останавливающийся на речи, заставляет модель продолжать её, а промпт, заканчивающийся длинной тишиной, задерживает начало), после чего батч дополняется справа до кратного размеру кадра токенизатора.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L106)

**Параметры:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Монофоническая волна или батч монофонических волн голосовых подсказок.

sampling_rate (`int`, *optional*) : Частота дискретизации, с которой была оцифрована входная `audio`. Настоятельно рекомендуется передавать `sampling_rate` при вызове forward, чтобы избежать скрытых ошибок.

end_on_pause (`bool`, *необязательный*) : Определяет, следует ли завершать каждую звуковую волну короткой паузой, см. docstring класса. По умолчанию `self.end_on_pause`.

padding (`bool`, `str` или [PaddingStrategy](/docs/transformers/main/ru/internal/file_utils#transformers.utils.PaddingStrategy), *необязательный*, по умолчанию `True`) : Стратегия выравнивания батча, см. [pad()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

pad_to_multiple_of (`int`, *optional*) : Выравнивание батча до кратного этому значению. По умолчанию `self.pad_to_multiple_of`.

## PocketTTSProcessor[[transformers.PocketTTSProcessor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L51)

**Параметры:**

feature_extractor (`PocketTTSFeatureExtractor`) : Извлекатель признаков является обязательным входом.

tokenizer (`TokenizersBackend`) : Токенизатор является обязательным входным параметром.

audio_tokenizer (`PocketTTSAudioTokenizerModel`, *необязательный*) : кодек: кодирует аудио в латенты и декодирует сгенерированные латенты в аудио.

chat_template (`str`) : Шаблон Jinja для преобразования списков сообщений в чате в строку, готовую к токенизации.

short_text_max_words (`int`, *optional*, по умолчанию 4) : Для текстов длиной не более этого количества слов после кадра конца речи добавляется `frames_after_eos_short_text` кадров.

frames_after_eos_short_text (`int`, *optional*, по умолчанию 4) : Количество кадров, генерируемых после кадра конца речи для коротких текстов.

frames_after_eos (`int`, *необязательный*, по умолчанию 2) : Количество кадров, генерируемых после кадра конца речи для более длинных текстов.

fade_in_duration (`float`, *optional*, по умолчанию 0.005) : Длительность в секундах линейного плавного нарастания громкости, применяемого к началу каждой декодированной звуковой волны: новое состояние декодера начинается с малого скачка, который воспринимается как щелчок.

Создаёт PocketTTSProcessor, который объединяет экстрактор признаков и токенизатор в единый процессор.

[PocketTTSProcessor](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor) предоставляет все возможности [PocketTTSFeatureExtractor](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) и [TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend). Подробнее см. в [~PocketTTSFeatureExtractor](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) и [~TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend).

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L109)

**Параметры:**

text (`str` или `list[str]`) : Промпт(ы), сформированный(е) с помощью [apply_chat_template()](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

audio (`np.ndarray`, `torch.Tensor` или список из них, *необязательно*) : Волновые формы разговоров, моно, 24 кГц, в порядке разговора: каждый голос, а при обучении — каждая целевая.

audio_prompt_latents (`list[torch.Tensor]`, *необязательный*) : Предвычисленные голоса, по одному тензору `(num_frames, latent_dim)` на каждый плейсхолдер голоса, вместо волновых форм.

labels (`list[torch.Tensor]`, *необязательный*) : Предвычисленные целевые значения (для обучения), по одному тензору `(num_frames, latent_dim)` на каждый плейсхолдер целевых значений, вместо волновых форм.

end_on_pause (`bool`, *kwargs*, *optional*) : Определяет, следует ли завершать каждую аудиоволну голосового промпта короткой паузой, как это делает оригинальная реализация перед клонированием голоса. По умолчанию используется значение `end_on_pause` из feature extractor.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

**Возвращаемое значение:**

[BatchFeature](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.BatchFeature) с `input_ids`, `attention_mask`, `audio_prompt_latents` и `audio_prompt_latents_mask`; для генерации `frames_after_eos` (кадры, сгенерированные после кадра конца речи, по длине текста), для обучения `labels` и `labels_mask`.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L285)

**Параметры:**

text (`str`) : Текст для разделения.

max_tokens (`int`, *необязательный*, по умолчанию 50) : Максимальное количество токенов в одном блоке.

Разбивает `text` на фрагменты, выровненные по предложениям и не превышающие `max_tokens` токенов, как в оригинальном методе `split_into_best_sentences`: подготовленный текст разрезается после окончания предложений (а не после десятичных точек), предложения длиннее `max_tokens` — после окончания частей, а затем фрагменты жадно группируются. Каждый фрагмент предназначен для того, чтобы составлять один диалог в батче.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L343)

**Параметры:**

audio_latents (`torch.Tensor` формы `(batch_size, num_frames, latent_dim)` или `(num_frames, latent_dim)`) : латенты, которые возвращает `generate` (`PocketTTSGenerateOutput.audio_latents`), декодированные как одна партия, либо латенты одного примера.

audio_latents_mask (`torch.Tensor` формы `(batch_size, num_frames)`, *необязательный*) : Маска кадров для каждого примера (`PocketTTSGenerateOutput.audio_latents_mask`). Если она не задана, каждая строка декодируется на полную длину.

**Возвращаемое значение:**

`list[torch.Tensor]` с одномерными волновыми формами на CPU, по одной на строку, или одной волновой формой для латентов одного примера.

Декодирует сгенерированные латенты в звуковые волны с помощью аудио-токенизатора и плавно усиливает первые `fade_in_duration` секунд каждого сигнала, как в оригинале.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L392)

Записывает сгенерированные звуковые волны в файл(ы) WAV.

audio (`torch.Tensor`, `np.ndarray` или список из них): волна(ы), как возвращаемые [decode()](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode). saving_path (`str`, `Path` или список из них): один путь на каждую волну. sampling_rate (`int`, *optional*): частота дискретизации волн, по умолчанию — частота извлекателя признаков (аудиотокенизатора).

## PocketTTSModel[[transformers.PocketTTSModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L498)

**Параметры:**

config ([PocketTTSConfig](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Базовая модель Pocket TTS: каузальный трансформер, работающий с одним потоком, состоящим из голосового промпта, токенов текста и латентных представлений аудио, и возвращающий нормализованные скрытые состояния. Голосовой промпт и латентные представления аудио являются латентами аудио-токенизатора, которые хранятся в процессоре.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L518)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` формы `(batch_size, num_prompt_frames, latent_dim)`, *необязательный*) : Латентные представления голосовых подсказок аудиотокенизатора (закодированные процессором или из `voices/` контрольной точки), дополненные справа до длины самой длинной голосовой подсказки в батче и размещённые в позициях `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` формы `(batch_size, num_prompt_frames)`, *необязательный*) : Маска кадров голоса (`1`) в отличие от заполнителей (`0`) в `audio_prompt_latents`.

audio_latents (`torch.Tensor` формы `(batch_size, num_latents, latent_dim)`, *необязательный*) : Нормализованные аудио-латенты, распределённые по позициям `audio_latent_token_id`. Позиция `audio_bos_token_id` перед ними, которая завершает промпт и с которой генерируется первый кадр, всегда получает обученный BOS-латент.

audio_latents_mask (`torch.Tensor` формы `(batch_size, num_latents)`, *необязательный*) : Маска латентов каждой строки (`1`) в отличие от заполнителей (`0`) в `audio_latents`, если строки содержат разное количество латентных позиций (обучение).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

**Возвращает:** [BaseModelOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([PocketTTSConfig](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSConfig)) и входных данных.

Метод forward модели [PocketTTSModel](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.

  Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L672)

**Параметры:**

config ([PocketTTSConfig](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Pocket TTS для синтеза речи: базовая сеть (backbone), flow-головка, которая на каждом шаге генерирует один аудиолатент, и головка для определения конца речи. Она генерирует латенты аудиотокенизатора, которые процессор декодирует в аудио с частотой 24 кГц.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L702)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` формы `(batch_size, num_prompt_frames, latent_dim)`, *необязательный*) : Латентные представления голосового промпта аудиотокенизатора, дополненные справа, распределённые по позициям `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` формы `(batch_size, num_prompt_frames)`, *необязательный*) : Маска кадров голоса (`1`) в отличие от заполнителей (`0`) в `audio_prompt_latents`.

audio_latents (`torch.Tensor` формы `(batch_size, num_latents, latent_dim)`, *необязательный*) : Нормализованные аудио-латенты, распределённые по позициям `audio_latent_token_id`.

labels (`torch.Tensor` формы `(batch_size, num_frames, latent_dim)`, *необязательный*) : Целевые латенты аудио-токенизатора (обучение), дополненные справа. Промпт каждой строки заканчивается позицией `audio_bos_token_id`, за которой следует по одной позиции `audio_latent_token_id` на каждый кадр: модель подаёт нормализованные целевые значения (teacher forcing), применяет flow loss к выходам BOS и всех кадров, кроме последнего, которые предсказывают кадры, а end-of-speech loss — ко всем, причём последний является концом речи.

labels_mask (`torch.Tensor` формы `(batch_size, num_frames)`, *необязательный*) : Маска целевых кадров каждой строки (`1`) в отличие от заполнителей (`0`) в `labels`.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

**Возвращает:** `PocketTTSOutputWithPast` или `tuple(torch.Tensor)`

Объект `PocketTTSOutputWithPast` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([PocketTTSConfig](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSConfig)) и входных данных.

Метод forward класса [PocketTTSForConditionalGeneration](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSForConditionalGeneration) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `()`, *необязательный*, возвращается при передаче `labels`) -- Потери обучения: потери потока LSD для целевых латентов плюс `config.eos_loss_weight` умноженное на потери конца речи.
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, 1)`) -- Логиты конца речи, по одному на каждую позицию.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Нормализованные скрытые состояния базовой модели, задающие условия для flow-головы.

Пример:

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

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

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

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/generation_pocket_tts.py#L122)

**Параметры:**

inputs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : `input_ids`, подготовленные с помощью [PocketTTSProcessor](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor). Также можно передать как `input_ids=`.

kwargs (`dict[str, Any]`, *необязательный*) : `attention_mask`, голосовой промпт (`audio_prompt_latents` и `audio_prompt_latents_mask`, либо кэш голосового префикса в виде `past_key_values`, встроенные голоса, с промптами только текста), `frames_after_eos` из процессора, параметры генерации (`do_sample`, `temperature`, `max_new_tokens`, ...), а также специфичные для Pocket TTS `num_flow_steps`, `eos_threshold` и `min_frames_before_eos`, значения по умолчанию для которых берутся из конфигурации генерации.

**Возвращаемое значение:**

[PocketTTSGenerateOutput](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) при `return_dict_in_generate=True` (конфигурация генерации чекпоинтов): дополненные `audio_latents` и их `audio_latents_mask`, которые [PocketTTSProcessor.decode()](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) декодирует как одну партию. В противном случае — список сгенерированных латентов, по одному тензору `(num_frames, latent_dim)` на образец, каждый из которых декодируется отдельно.

Генерирует речь. Этот метод переопределяет [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate), чтобы по умолчанию устанавливать `max_new_tokens` равным бюджету кадров исходного времени выполнения, `ceil((num_text_tokens / 3 + 2) * frame_rate)` для самого длинного текста в батче. Всё остальное проходит через стандартные хуки генерации.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L807)

**Параметры:**

condition (`torch.Tensor` формы `(batch_size, hidden_size)`) : Скрытое состояние бэкбона для генерируемой позиции.

noise (`torch.Tensor` формы `(batch_size, latent_dim)`) : гауссов шум, масштабированный на `sqrt(temperature)`, или нули.

num_flow_steps (`int`) : Количество шагов Эйлера для сэмплера LSD (игнорируется дрейфующей головой, которая выполняет один вызов).

**Возвращает:** `torch.Tensor` формы `(batch_size, latent_dim)`

сэмплированный латентный вектор в нормализованном пространстве.

Выбирает следующий латентный вектор из `noise` с помощью flow-головы.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L854)

Преобразует латенты из нормализованного пространства flow head в пространство аудио-токенизатора.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/generation_pocket_tts.py#L40)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size, sequence_length)`) : идентификаторы токенов подсказки, за которыми следует один `audio_latent_token_id` на каждый сгенерированный кадр. Само аудио находится в `audio_latents`.

scores (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_scores=True`) : Логит конца речи для каждого сгенерированного кадра, один тензор формы `(batch_size,)` на кадр.

logits (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_logits=True`) : Аналогично `scores`: у Pocket TTS нет словаря, поэтому между ними нечего обрабатывать.

attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный кадр) кортежей (по одному элементу на каждый слой) `torch.Tensor` формы `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_hidden_states=True`) : Кортеж (по одному элементу для каждого сгенерированного кадра) кортежей (по одному элементу для каждого слоя) `torch.Tensor` формы `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *необязательный*, возвращается при `use_cache=True`) : Кэш ключей/значений базовой модели в конце генерации.

audio_latents (`torch.Tensor` формы `(batch_size, num_frames, latent_dim)`) : Сгенерированные латенты в латентном пространстве аудио-токенизатора, дополненные нулями справа за пределами собственных кадров каждого примера. [PocketTTSProcessor.decode()](/docs/transformers/main/ru/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) преобразует их в звуковые сигналы.

audio_latents_mask (`torch.LongTensor` формы `(batch_size, num_frames)`) : Маска кадров каждого примера (`1`), включая кадр конца речи и все кадры после него, в отличие от заполнителей (`0`).

Результаты `PocketTTSForConditionalGeneration.generate`.