Hugging Face's logo

Transformers documentation

Pocket TTS

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 2026-10-20.

Pocket TTS

Visão geral

O Pocket TTS é o modelo de texto para fala de 100M de parâmetros da Kyutai, um Continuous Audio Language Model que roda mais rápido que o tempo real em CPU. Um transformer causal emite um latente de áudio contínuo por frame (12,5 Hz) por meio de uma cabeça de fluxo de um passo, e uma cabeça de fim de fala decide quando parar.

O processador contém o tokenizador de áudio do Pocket TTS, um codec baseado no Mimi que codifica prompts de voz e decodifica os latentes gerados em áudio de 24 kHz. As vozes predefinidas são fornecidas como caches de KV (voices/).

Duas cabeças de fluxo são disponibilizadas: auto-destilação lagrangiana (flow_type="lsd", padrão) e em deriva (flow_type="drifting", english_drifting_26-09). O ajuste fino é suportado, consulte Training.

Este modelo foi contribuído por Eustache Le Bihan. O código original é kyutai-labs/pocket-tts.

Dicas de uso

  • Prepare os inputs com apply_chat_template() (uma mensagem user por texto, add_generation_prompt=True). O normalizador do tokenizer prepara o texto como no original, com as configurações do idioma do checkpoint.
  • generate retorna audio_latents e audio_latents_mask; decodifique-os com PocketTTSProcessor.decode().
  • max_new_tokens tem como padrão um orçamento baseado no comprimento do texto, e a geração é interrompida pouco depois que o logit de fim de fala ultrapassa eos_threshold.
  • do_sample=False corresponde ao original em temperatura 0. Com amostragem, temperature (padrão 0,3) é a variância do ruído inicial do fluxo.
  • Divida textos longos com PocketTTSProcessor.split_text(), uma conversa por bloco.

Uso

Voz

A voz pode ser fornecida de três maneiras.

1. Clonando uma gravação: um item audio na conversa.

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. Latentes pré-computados: um item audio vazio, com os latentes passados para o processador.

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. Contexto em cache: o cache de KV do prompt de voz, passado como past_key_values. As vozes incluídas (voices/) usam esse formato.

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

Lotes e texto longo

Lote vários textos e vozes, com texto longo dividido em blocos:

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 em deriva

Mesmo uso, com as vozes do próprio checkpoint:

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

Treinamento

Coloque o áudio de destino no turno assistant. O processador retorna seus latentes como labels, e o modelo retorna a perda do original (perda de fluxo LSD mais config.eos_loss_weight vezes a perda de fim de fala). O prompt de voz é tipicamente o início da mesma fala.

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()
  • Forneça a voz como uma gravação ou latentes, não como um cache.
  • Para o classifier-free guidance, remova o item audio ou text da vez do user (o original remove cada um com probabilidade 0,2).
  • Os latentes pré-computados ficam em processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}, com itens vazios {"type": "audio"} como marcadores de posição.
  • Receita original: AdamW, learning_rate=2e-5 (2e-4 para um novo idioma), adam_beta2=0.95, weight_decay=0.1, max_grad_norm=1.0, 1000 passos de aquecimento e depois constante, EMA dos pesos (decay 0.999).

PocketTTSConfig

classe transformers.PocketTTSConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneflow_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevocab_size: int = 4004hidden_size: int = 1024num_hidden_layers: int = 6num_attention_heads: int = 16num_key_value_heads: int | None = Nonehead_dim: int | None = Noneintermediate_size: int = 4096hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-05attention_bias: bool = Falseattention_dropout: float = 0.0max_position_embeddings: int = 8192rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonelatent_dim: int = 32pad_token_id: int = 3bos_token_id: int | None = Noneeos_token_id: int | None = Noneaudio_prompt_token_id: int = 4000audio_latent_token_id: int = 4001audio_prompt_bos_token_id: int = 4002audio_bos_token_id: int = 4003frame_rate: float = 12.5initializer_range: float = 0.02use_cache: bool = Trueeos_loss_weight: float = 0.1flow_loss_num_samples: int = 4lsd_distill_probability: float = 0.25lsd_diagonal_weight: float = 0.75lsd_time_logit_mean: float = 0.4lsd_time_logit_std: float = 1.0latent_stats_ema_steps: int = 1000latent_stats_ema_decay: float = 0.999 )

Parâmetros

  • flow_head_config (Union[PocketTTSFlowHeadConfig, dict], opcional) — A configuração do flow head que amostra cada latente a partir do estado oculto do backbone.
  • vocab_size (int, opcional, padrão 4004) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 6) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • head_dim (int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • hidden_act (str, opcional, padrão gelu_pytorch_tanh) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, padrão 1e-05) — Epsilon das normalizações de camada do backbone.
  • attention_bias (bool, opcional, padrão False) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • attention_dropout (float, opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • max_position_embeddings (int, opcional, padrão 8192) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.
  • latent_dim (int, opcional, padrão 32) — Dimensão dos latentes de áudio que o backbone recebe como entrada (audio_prompt_latents, audio_latents); igual à latent_dim do flow head e do tokenizer de áudio.
  • pad_token_id (int, opcional, padrão 3) — ID do token usado para preenchimento (padding) no vocabulário.
  • bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (int, opcional) — ID do token usado para o fim do fluxo no vocabulário.
  • audio_prompt_token_id (int, opcional, padrão 4000) — ID do token placeholder dos quadros de prompt de voz em input_ids.
  • audio_latent_token_id (int, opcional, padrão 4001) — ID do token placeholder das posições latentes de áudio em input_ids.
  • audio_prompt_bos_token_id (int, opcional, padrão 4002) — ID do token colocado antes do prompt de voz; seu embedding é o vetor aprendido que o original adiciona ao início da voz.
  • audio_bos_token_id (int, opcional, padrão 4003) — ID do token da primeira posição de áudio, que fecha o prompt: ele contém o latente BOS aprendido, a partir do qual o primeiro frame é gerado.
  • frame_rate (float, opcional, padrão 12.5) — Número de latentes de áudio por segundo de áudio: generate deriva seu orçamento de quadros padrão a partir dele.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • eos_loss_weight (float, opcional, padrão 0.1) — Peso da perda de fim de fala na perda de treinamento.
  • flow_loss_num_samples (int, opcional, padrão 4) — Número de amostras de ruído por quadro alvo na perda de fluxo.
  • lsd_distill_probability (float, opcional, padrão 0.25) — Probabilidade, por etapa de treinamento, de calcular o termo de auto-destilação da perda LSD (reponderado para manter a perda esperada); 1 o calcula em todas as etapas.
  • lsd_diagonal_weight (float, opcional, padrão 0.75) — Peso do termo diagonal (fluxo instantâneo) da perda LSD; o termo de auto-distilação pondera o restante.
  • lsd_time_logit_mean (float, opcional, padrão 0.4) — Média da distribuição logit-normal dos tempos de fluxo extraídos pela perda LSD.
  • lsd_time_logit_std (float, opcional, padrão 1.0) — Desvio padrão da distribuição logit-normal dos tempos de fluxo extraídos pela perda LSD.
  • latent_stats_ema_steps (int, opcional, padrão 1000) — Número de primeiros passos de treinamento durante os quais latent_mean e latent_std seguem uma média móvel exponencial dos latentes alvo; 0 os mantém congelados.
  • latent_stats_ema_decay (float, opcional, padrão 0.999) — Decaimento dessa média móvel.

Esta é a classe de configuração para armazenar a configuração de um PocketTTSModel. Ela é usada para instanciar um modelo Pocket Tts de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do eustlb/pocket-tts

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

PocketTTSFlowHeadConfig

classe transformers.PocketTTSFlowHeadConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 512num_hidden_layers: int = 6latent_dim: int = 32condition_dim: int = 1024frequency_embedding_size: int = 256hidden_act: str = 'silu'layer_norm_eps: float = 1e-06rms_norm_eps: float = 1e-05max_period: float = 10000.0flow_type: typing.Literal['lsd', 'drifting'] = 'lsd'loss_weighting_hidden_size: int = 32loss_weighting_num_layers: int = 3 )

Parâmetros

  • hidden_size (int, opcional, padrão 512) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 6) — Número de camadas ocultas no decodificador do Transformer.
  • latent_dim (int, opcional, padrão 32) — Dimensão dos latentes contínuos de áudio que a head prevê (a dimensão latente do tokenizer de áudio).
  • condition_dim (int, opcional, padrão 1024) — Dimensão do estado oculto do backbone em que a cabeça é condicionada (o hidden_size do backbone).
  • frequency_embedding_size (int, opcional, padrão 256) — Tamanho do embedding senoidal dos tempos de fluxo.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, padrão 1e-06) — Epsilon das normalizações de camada dentro dos blocos residuais e da camada final.
  • rms_norm_eps (float, opcional, padrão 1e-05) — Epsilon da normalização que fecha os embeddings de tempo.
  • max_period (float, opcional, padrão 10000.0) — Período máximo do embedding temporal sinusoidal, que o checkpoint armazena como freqs.
  • flow_type (str, opcional, padrão "lsd") — Objetivo com o qual a head foi treinada, que define como ela é condicionada e amostrada. "lsd" (auto-distilação lagrangiana): condicionada nos tempos inicial e final de uma etapa de fluxo, amostrada por etapas de Euler a partir de ruído gaussiano. "drifting": sem condicionamento temporal, a head mapeia o ruído para o latente em uma única chamada.
  • loss_weighting_hidden_size (int, opcional, padrão 32) — Largura do MLP que aprende o ponderamento de incerteza dos termos de perda LSD a partir de seus tempos de fluxo (apenas para treinamento).
  • loss_weighting_num_layers (int, opcional, padrão 3) — Número de camadas ocultas desse MLP.

Esta é a classe de configuração para armazenar a configuração de um PocketTTSModel. Ela é usada para instanciar um modelo Pocket Tts de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do eustlb/pocket-tts

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

PocketTTSFeatureExtractor

classe transformers.PocketTTSFeatureExtractor

< >

( feature_size = 1sampling_rate = 24000padding_value = 0.0frame_size = 1920pad_to_multiple_of = 1920end_on_pause = Truepause_duration = 0.08fade_out_duration = 0.02silence_floor_db = 35.0analysis_frame_duration = 0.02**kwargs )

Parâmetros

  • feature_size (int, opcional, padrão 1) — O número de canais.
  • sampling_rate (int, opcional, padrão 24000) — A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).
  • padding_value (float, opcional, padrão 0.0) — O valor utilizado para preenchimento.
  • frame_size (int, opcional, padrão 1920) — Número de amostras de áudio por quadro latente do tokenizador de áudio (seu frame_size).
  • pad_to_multiple_of (int, opcional, padrão 1920) — Preenche o áudio até um múltiplo deste valor; um múltiplo de frame_size mantém todos os quadros latentes inteiros.
  • end_on_pause (bool, opcional, padrão True) — Se deve encerrar cada forma de onda exatamente em pause_duration segundos de silêncio: o silêncio final (quadros de analysis_frame_duration segundos abaixo de silence_floor_db em relação ao mais alto) é cortado, os últimos fade_out_duration segundos do que resta são atenuados e pause_duration segundos de zeros são adicionados.
  • pause_duration (float, opcional, padrão 0.08) — Duração do silêncio adicionado por end_on_pause, em segundos.
  • fade_out_duration (float, opcional, padrão 0.02) — Duração do fade-out aplicado por end_on_pause antes da pausa, em segundos.
  • silence_floor_db (float, opcional, padrão 35.0) — Nível abaixo do quadro de análise mais alto, em dB, abaixo do qual end_on_pause trata os quadros finais como silêncio.
  • analysis_frame_duration (float, opcional, padrão 0.02) — Duração dos quadros que end_on_pause mede, em segundos.

Constrói um extrator de recursos do Pocket TTS, que prepara as formas de onda de prompts de voz para o codificador do tokenizador de áudio.

Cada forma de onda termina opcionalmente em uma breve pausa (o end_on_pause original: os prompts de treinamento terminam dentro da pausa entre duas palavras, um prompt que para na fala faz o modelo continuar e um que termina em um silêncio longo atrasa o início), em seguida o lote é preenchido à direita até um múltiplo do tamanho de quadro do tokenizer.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]sampling_rate: int | None = Noneend_on_pause: bool | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy | None = Truepad_to_multiple_of: int | None = Nonemax_length: int | None = Nonereturn_attention_mask: bool | None = Truereturn_tensors: str | None = 'pt'**kwargs )

Parâmetros

  • audio (np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — A forma de onda mono ou o lote de formas de onda mono dos prompts de voz.
  • sampling_rate (int, opcional) — A taxa de amostragem na qual a entrada de audio foi amostrada. É fortemente recomendável passar sampling_rate na chamada de forward para evitar erros silenciosos.
  • end_on_pause (bool, opcional) — Se deve encerrar cada forma de onda com uma breve pausa, consulte a docstring da classe. O valor padrão é self.end_on_pause.
  • padding (bool, str ou PaddingStrategy, opcional, padrão True) — Estratégia de preenchimento do lote, veja pad().
  • pad_to_multiple_of (int, opcional) — Preenche o lote até um múltiplo deste valor. O padrão é self.pad_to_multiple_of.

PocketTTSProcessor

classe transformers.PocketTTSProcessor

< >

( feature_extractortokenizeraudio_tokenizer = Nonechat_template = Noneshort_text_max_words: int = 4frames_after_eos_short_text: int = 4frames_after_eos: int = 2fade_in_duration: float = 0.005 )

Parâmetros

  • feature_extractor (PocketTTSFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (TokenizersBackend) — O tokenizer é uma entrada obrigatória.
  • audio_tokenizer (PocketTTSAudioTokenizerModel, opcional) — O codec: ele codifica o áudio em latentes e decodifica os latentes gerados em áudio.
  • chat_template (str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
  • short_text_max_words (int, opcional, padrão 4) — Textos com no máximo esse número de palavras recebem frames_after_eos_short_text frames após o frame de fim de fala.
  • frames_after_eos_short_text (int, opcional, padrão 4) — Número de quadros gerados após o quadro de fim de fala para textos curtos.
  • frames_after_eos (int, opcional, padrão 2) — Número de quadros gerados após o quadro de fim de fala para textos mais longos.
  • fade_in_duration (float, opcional, padrão 0.005) — Duração, em segundos, do fade-in linear aplicado ao início de cada forma de onda decodificada: um novo estado do decodificador começa com um pequeno degrau, ouvido como um clique.

Constrói um PocketTTSProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

PocketTTSProcessor oferece todas as funcionalidades de PocketTTSFeatureExtractor e TokenizersBackend. Consulte ~PocketTTSFeatureExtractor e ~TokenizersBackend para mais informações.

__call__

< >

( text: str | list[str] | None = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneaudio_prompt_latents: list[torch.Tensor] | None = Nonelabels: list[torch.Tensor] | None = None**kwargs: *<class 'transformers.models.pocket_tts.processing_pocket_tts.PocketTTSProcessorKwargs'> )

Parâmetros

  • text (str ou list[str]) — O(s) prompt(s) renderizado(s) por apply_chat_template().
  • audio (np.ndarray, torch.Tensor ou uma lista deles, opcional) — As formas de onda das conversas, mono a 24 kHz, na ordem da conversa: cada voz e, no treinamento, cada alvo.
  • audio_prompt_latents (list[torch.Tensor], opcional) — Vozes pré-computadas, um tensor (num_frames, latent_dim) por marcador de voz, em vez de formas de onda.
  • labels (list[torch.Tensor], opcional) — Alvos precomputados (treinamento), um tensor (num_frames, latent_dim) por placeholder de alvo, em vez de formas de onda.
  • end_on_pause (bool, kwargs, opcional) — Se deve encerrar cada forma de onda do prompt de voz com uma breve pausa, como o original faz antes de clonar uma voz. Padrão: end_on_pause do extrator de recursos.
  • return_mm_token_type_ids (bool, kwargs) — Se deve retornar os ids de tipo de token multimodal indicando as posições dos tokens placeholder multimodais.
  • return_text_replacement_offsets (bool, kwargs) — Se deve retornar os deslocamentos de caracteres para cada placeholder multimodal e sua substituição.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

split_text

< >

( text: strmax_tokens: int = 50 )

Parâmetros

  • text (str) — O texto a ser dividido.
  • max_tokens (int, opcional, padrão 50) — Número máximo de tokens por bloco.

Divide text em blocos alinhados por sentenças, com no máximo max_tokens tokens, como no split_into_best_sentences original: o texto preparado é cortado após o fim das sentenças (não em pontos decimais), sentenças mais longas que max_tokens são cortadas após o fim das orações, e os pedaços são agrupados de forma gulosa. Cada bloco deve corresponder a uma conversa de um lote.

decode

< >

( audio_latents: torch.Tensoraudio_latents_mask: torch.Tensor | None = None )

Parâmetros

  • audio_latents (torch.Tensor de forma (batch_size, num_frames, latent_dim) ou (num_frames, latent_dim)) — Os latentes que generate retorna (PocketTTSGenerateOutput.audio_latents), decodificados como um único lote, ou os latentes de uma amostra.
  • audio_latents_mask (torch.Tensor de forma (batch_size, num_frames), opcional) — Máscara dos frames de cada amostra (PocketTTSGenerateOutput.audio_latents_mask). Sem ela, cada linha é decodificada no comprimento total.

Decodifica os latentes gerados em formas de onda com o tokenizador de áudio e aplica um fade-in nos primeiros fade_in_duration segundos de cada uma, assim como no original.

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 )

Grava a(s) forma(s) de onda gerada(s) em arquivo(s) WAV.

audio (torch.Tensor, np.ndarray ou uma lista deles): As formas de onda, conforme retornadas por decode(). saving_path (str, Path ou uma lista deles): Um caminho para cada forma de onda. sampling_rate (int, opcional): Taxa de amostragem das formas de onda, por padrão a do extrator de recursos (do tokenizador de áudio).

PocketTTSModel

classe transformers.PocketTTSModel

< >

( config: PocketTTSConfig )

Parâmetros

  • config (PocketTTSConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O backbone do Pocket TTS: um transformer causal sobre um único fluxo composto pelo prompt de voz, os tokens de texto e os latentes de áudio, retornando os estados ocultos normalizados. O prompt de voz e os latentes de áudio são latentes do tokenizador de áudio, que o processador mantém.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneaudio_prompt_latents: typing.Optional[torch.Tensor] = Noneaudio_prompt_latents_mask: typing.Optional[torch.Tensor] = Noneaudio_latents: typing.Optional[torch.Tensor] = Noneaudio_latents_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • audio_prompt_latents (torch.Tensor de forma (batch_size, num_prompt_frames, latent_dim), opcional) — Latentes do prompt de voz do tokenizador de áudio (codificados pelo processador, ou do voices/ de um checkpoint), preenchidos à direita até a voz mais longa do lote, distribuídos nas posições de audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forma (batch_size, num_prompt_frames), opcional) — Máscara dos quadros de voz (1) em oposição ao preenchimento (0) em audio_prompt_latents.
  • audio_latents (torch.Tensor de forma (batch_size, num_latents, latent_dim), opcional) — Latentes de áudio normalizados, distribuídos nas posições de audio_latent_token_id. A posição de audio_bos_token_id antes deles, que fecha o prompt e a partir da qual o primeiro frame é gerado, sempre recebe o latente de BOS aprendido.
  • audio_latents_mask (torch.Tensor de forma (batch_size, num_latents), opcional) — Máscara dos latentes de cada linha (1) em oposição ao preenchimento (0) em audio_latents, quando as linhas contêm diferentes números de posições latentes (treinamento).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

BaseModelOutputWithPast ou tuple(torch.Tensor)

Um BaseModelOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo vários elementos dependendo da configuração (PocketTTSConfig) e das entradas.

O método forward do PocketTTSModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

PocketTTSForConditionalGeneration

classe transformers.PocketTTSForConditionalGeneration

< >

( config: PocketTTSConfig )

Parâmetros

  • config (PocketTTSConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo de texto para fala Pocket TTS: o backbone, o flow head que amostra um latente de áudio por passo e o end-of-speech head. Ele gera latentes do tokenizer de áudio, que o processador decodifica em áudio de 24 kHz.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneaudio_prompt_latents: typing.Optional[torch.Tensor] = Noneaudio_prompt_latents_mask: typing.Optional[torch.Tensor] = Noneaudio_latents: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonelabels_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • audio_prompt_latents (torch.Tensor de forma (batch_size, num_prompt_frames, latent_dim), opcional) — Latentes do prompt de voz do tokenizer de áudio, com preenchimento à direita, distribuídos nas posições de audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forma (batch_size, num_prompt_frames), opcional) — Máscara dos quadros de voz (1) em oposição ao preenchimento (0) em audio_prompt_latents.
  • audio_latents (torch.Tensor de forma (batch_size, num_latents, latent_dim), opcional) — Latentes de áudio normalizados, distribuídos nas posições de audio_latent_token_id.
  • labels (torch.Tensor de forma (batch_size, num_frames, latent_dim), opcional) — Latentes de destino do tokenizer de áudio (treinamento), com preenchimento à direita. O prompt de cada linha termina na posição do audio_bos_token_id seguido por uma posição de audio_latent_token_id por quadro: o modelo fornece os destinos normalizados (teacher forcing), aplica a perda de fluxo às saídas do BOS e de todos os quadros, exceto o último, que preveem os quadros, e a perda de fim de fala a todos eles, sendo o último o fim da fala.
  • labels_mask (torch.Tensor de forma (batch_size, num_frames), opcional) — Máscara dos frames-alvo de cada linha (1) em oposição ao padding (0) em labels.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

PocketTTSOutputWithPast ou tuple(torch.Tensor)

Um PocketTTSOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo vários elementos dependendo da configuração (PocketTTSConfig) e das entradas.

O método forward de PocketTTSForConditionalGeneration substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (), opcional, retornado quando labels é passado) — Perda de treinamento: a perda de fluxo LSD dos latentes de destino mais config.eos_loss_weight vezes a perda de fim de fala.

  • logits (torch.Tensor de forma (batch_size, sequence_length, 1)) — Logits de fim de fala, um por posição.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Estados ocultos normalizados do backbone, que condicionam a cabeça de fluxo.

Exemplo:

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

< >

( inputs: typing.Optional[torch.Tensor] = None**kwargs )

Parâmetros

  • inputs (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Os input_ids preparados pelo PocketTTSProcessor. Também pode ser passado como input_ids=.
  • kwargs (dict[str, Any], opcional) — attention_mask, o prompt de voz (audio_prompt_latents e audio_prompt_latents_mask, ou o cache de um prefixo de voz como past_key_values, as vozes incluídas, com prompts apenas de texto), frames_after_eos do processador, os parâmetros de geração (do_sample, temperature, max_new_tokens, …) e os específicos do Pocket TTS num_flow_steps, eos_threshold e min_frames_before_eos, que por padrão seguem a configuração de geração.

Gera fala. Este método substitui generate() para definir max_new_tokens como o orçamento de quadros do tempo de execução original, ceil((num_text_tokens / 3 + 2) * frame_rate) para o texto mais longo do lote. Todo o restante passa pelos ganchos de geração regulares.

sample_latent

< >

( condition: Tensornoise: Tensornum_flow_steps: int ) → torch.Tensor of shape (batch_size, latent_dim)

Parâmetros

  • condition (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto do backbone da posição sendo gerada.
  • noise (torch.Tensor de forma (batch_size, latent_dim)) — ruído gaussiano escalado por sqrt(temperature), ou zeros.
  • num_flow_steps (int) — Número de etapas de Euler do amostrador LSD (ignorado pela cabeça de derivação, que faz uma única chamada).

Retorna

torch.Tensor de forma (batch_size, latent_dim)

o latente amostrado, no espaço normalizado.

Amostra o próximo latente de noise com a flow head.

denormalize_latents

< >

( audio_latents: Tensor )

Mapeia os latentes do espaço normalizado da cabeça de fluxo para o do tokenizador de áudio.

PocketTTSGenerateOutput

classe transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput

< >

( sequences: LongTensorscores: tuple[torch.Tensor] | None = Nonelogits: tuple[torch.Tensor] | None = Noneattentions: tuple[tuple[torch.Tensor]] | None = Nonehidden_states: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneaudio_latents: typing.Optional[torch.Tensor] = Noneaudio_latents_mask: typing.Optional[torch.LongTensor] = None )

Parâmetros

  • sequences (torch.LongTensor de forma (batch_size, sequence_length)) — Os ids dos tokens do prompt seguidos por um audio_latent_token_id por quadro gerado. O próprio áudio está em audio_latents.
  • scores (tuple(torch.Tensor) opcional, retornado quando output_scores=True) — O logit de fim de fala de cada quadro gerado, um tensor de forma (batch_size,) por quadro.
  • logits (tuple(torch.Tensor) opcional, retornado quando output_logits=True) — Igual a scores: o Pocket TTS não possui vocabulário, portanto não há nada a processar entre os dois.
  • attentions (tuple(tuple(torch.Tensor)), opcional, retornado quando output_attentions=True) — Tupla (um elemento para cada quadro gerado) de tuplas (um elemento para cada camada) de torch.Tensor com forma (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(torch.Tensor)), opcional, retornado quando output_hidden_states=True) — Tupla (um elemento para cada quadro gerado) de tuplas (um elemento para cada camada) de torch.Tensor com forma (batch_size, generated_length, hidden_size).
  • past_key_values (Cache, opcional, retornado quando use_cache=True) — O cache de chave/valor do backbone no final da geração.
  • audio_latents (torch.Tensor de forma (batch_size, num_frames, latent_dim)) — Os latentes gerados, no espaço latente do tokenizer de áudio, com preenchimento à direita com zeros além dos próprios frames de cada amostra. PocketTTSProcessor.decode() os converte em formas de onda.
  • audio_latents_mask (torch.LongTensor de forma (batch_size, num_frames)) — Máscara dos frames de cada amostra (1), incluindo o frame de fim de fala e os frames subsequentes, em oposição ao preenchimento (0).

Saídas de PocketTTSForConditionalGeneration.generate.

Update on GitHub

←PE Audio Pocket TTS Audio Tokenizer→