Hugging Face's logo

Transformers documentation

Pocket TTS

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo fue aportado a Hugging Face Transformers el 2026-10-20.

Pocket TTS

Resumen

Pocket TTS es el modelo de texto a voz de 100 millones de parámetros de Kyutai, un Continuous Audio Language Model que se ejecuta más rápido que el tiempo real en CPU. Un transformer causal emite un latente de audio continuo por cuadro (12.5 Hz) a través de una cabeza de flujo de un solo paso, y una cabeza de fin de habla decide cuándo detenerse.

El procesador contiene el tokenizador de audio de Pocket TTS, un códec basado en Mimi que codifica los prompts de voz y decodifica los latentes generados a audio de 24 kHz. Las voces predefinidas se incluyen como cachés KV (voices/).

Se han publicado dos cabezas de flujo: autodistilación lagrangiana (flow_type="lsd", predeterminada) y derivante (flow_type="drifting", english_drifting_26-09). Se admite el ajuste fino, consulte Entrenamiento.

Este modelo fue aportado por Eustache Le Bihan. El código original es kyutai-labs/pocket-tts.

Consejos de uso

  • Prepara las entradas con apply_chat_template() (un mensaje de user por texto, add_generation_prompt=True). El normalizador del tokenizador prepara el texto como el original, con los ajustes del idioma del checkpoint.
  • generate devuelve audio_latents y audio_latents_mask; decódialos con PocketTTSProcessor.decode().
  • max_new_tokens tiene un valor predeterminado basado en la longitud del texto, y la generación se detiene poco después de que el logit de fin de habla cruce eos_threshold.
  • do_sample=False coincide con el original a temperatura 0. Con muestreo, temperature (predeterminado 0.3) es la varianza del ruido inicial del flujo.
  • Divide el texto largo con PocketTTSProcessor.split_text(), una conversación por fragmento.

Uso

Voz

La voz puede otorgarse de tres maneras.

1. Clonar una grabación: un elemento audio en la conversación.

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 precalculados: un elemento audio vacío, con los latentes pasados al procesador.

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 en caché: la caché KV del prompt de voz, pasada como past_key_values. Las voces incluidas (voices/) utilizan esta forma.

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 y texto largo

Lote varios textos y voces, con el texto largo dividido en fragmentos:

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

Punto de control desviado

Mismo uso, con las voces propias del punto de control:

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

Entrenamiento

Coloca el audio objetivo en el turno assistant. El procesador devuelve sus latentes como labels, y el modelo devuelve la pérdida original (pérdida de flujo LSD más config.eos_loss_weight veces la pérdida de fin de habla). El prompt de voz suele ser el comienzo del mismo enunciado.

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()
  • Proporciona la voz como una grabación o latentes, no como una caché.
  • Para la guía sin clasificador, elimine el elemento audio o text del turno de user (el original elimina cada uno con una probabilidad de 0.2).
  • Los latentes precalculados se incluyen en processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}, con elementos vacíos de {"type": "audio"} como marcadores de posición.
  • Receta original: AdamW, learning_rate=2e-5 (2e-4 para un nuevo idioma), adam_beta2=0.95, weight_decay=0.1, max_grad_norm=1.0, 1000 pasos de calentamiento y luego constante, EMA de los pesos (decaimiento 0.999).

PocketTTSConfig

clase 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) — La configuración de la cabecera de flujo que muestrea cada latente a partir del estado oculto del backbone.
  • vocab_size (int, opcional, valor predeterminado 4004) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • hidden_size (int, opcional, valor predeterminado 1024) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 6) — Número de capas ocultas en el decodificador Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • num_key_value_heads (int, opcional) — Este es el número de cabezas de key_value que se deben utilizar para implementar Grouped Query Attention. Si num_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); si num_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado será num_attention_heads.
  • head_dim (int, opcional) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads
  • intermediate_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones del MLP.
  • hidden_act (str, opcional, valor predeterminado gelu_pytorch_tanh) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-05) — Epsilon de las normalizaciones de capa del backbone.
  • attention_bias (bool, opcional, valor predeterminado False) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.
  • attention_dropout (float, opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • max_position_embeddings (int, opcional, valor predeterminado 8192) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para rope_theta y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con max_position_embeddings más largos.
  • latent_dim (int, opcional, valor predeterminado 32) — Dimensión de los latentes de audio que la arquitectura principal recibe como entrada (audio_prompt_latents, audio_latents); es igual a latent_dim de la cabeza de flujo y del tokenizador de audio.
  • pad_token_id (int, opcional, valor predeterminado 3) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (int, opcional) — Id del token utilizado para el fin de secuencia en el vocabulario.
  • audio_prompt_token_id (int, opcional, valor predeterminado 4000) — Id del token de marcador de posición de los fotogramas de la voz de la indicación en input_ids.
  • audio_latent_token_id (int, opcional, valor predeterminado 4001) — Id del token de marcador de posición de las posiciones latentes de audio en input_ids.
  • audio_prompt_bos_token_id (int, opcional, valor predeterminado 4002) — Id del token colocado antes del prompt de voz; su embedding es el vector aprendido que el original antepone a la voz.
  • audio_bos_token_id (int, opcional, valor predeterminado 4003) — Id del token de la primera posición de audio, que cierra el prompt: contiene el latente BOS aprendido, a partir del cual se genera el primer fotograma.
  • frame_rate (float, opcional, valor predeterminado 12.5) — Número de latentes de audio por segundo de audio: generate deriva su presupuesto de fotogramas predeterminado a partir de este valor.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante si config.is_decoder=True o cuando el modelo es un modelo generativo solo de decodificador.
  • eos_loss_weight (float, opcional, valor predeterminado 0.1) — Peso de la pérdida de fin de habla en la pérdida de entrenamiento.
  • flow_loss_num_samples (int, opcional, valor predeterminado 4) — Número de extracciones de ruido por cuadro objetivo en la pérdida de flujo.
  • lsd_distill_probability (float, opcional, valor predeterminado 0.25) — Probabilidad, por paso de entrenamiento, de calcular el término de auto-destilación de la pérdida LSD (recalculado para mantener la pérdida esperada); 1 lo calcula en cada paso.
  • lsd_diagonal_weight (float, opcional, valor predeterminado 0.75) — Peso del término diagonal (flujo instantáneo) de la pérdida LSD; el término de autodistilación pondera el resto.
  • lsd_time_logit_mean (float, opcional, valor predeterminado 0.4) — Media de la distribución logit-normal de los tiempos de flujo extraídos por la pérdida LSD.
  • lsd_time_logit_std (float, opcional, valor predeterminado 1.0) — Desviación estándar de la distribución logit-normal de los tiempos de flujo extraídos por la pérdida LSD.
  • latent_stats_ema_steps (int, opcional, valor predeterminado 1000) — Número de primeros pasos de entrenamiento durante los cuales latent_mean y latent_std siguen una media móvil exponencial de los latentes objetivo; 0 los mantiene congelados.
  • latent_stats_ema_decay (float, opcional, valor predeterminado 0.999) — Decaimiento de esa media móvil.

Esta es la clase de configuración para almacenar la configuración de un PocketTTSModel. Se utiliza para instanciar un modelo Pocket Tts según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de eustlb/pocket-tts

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

PocketTTSFlowHeadConfig

clase 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, valor predeterminado 512) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 6) — Número de capas ocultas en el decodificador Transformer.
  • latent_dim (int, opcional, valor predeterminado 32) — Dimensión de los latentes de audio continuos que predice la cabeza (la dimensión latente del tokenizador de audio).
  • condition_dim (int, opcional, valor predeterminado 1024) — Dimensión del estado oculto del backbone en el que se condiciona la cabeza (el hidden_size del backbone).
  • frequency_embedding_size (int, opcional, valor predeterminado 256) — Tamaño de la incrustación sinusoidal de los tiempos de flujo.
  • hidden_act (str, opcional, valor predeterminado silu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — Epsilon de las normalizaciones de capa dentro de los bloques residuales y la capa final.
  • rms_norm_eps (float, opcional, valor predeterminado 1e-05) — Epsilon de la normalización que cierra los embeddings temporales.
  • max_period (float, opcional, valor predeterminado 10000.0) — Período máximo de la incrustación sinusoidal de tiempo, que el punto de control almacena como freqs.
  • flow_type (str, opcional, valor predeterminado "lsd") — Objetivo con el que se entrenó la cabeza, que determina cómo se condiciona y muestrea. "lsd" (auto-destilación lagrangiana): condicionada en los tiempos de inicio y fin de un paso de flujo, muestreada mediante pasos de Euler desde ruido gaussiano. "drifting": sin condicionamiento temporal, la cabeza mapea el ruido al latente en una sola llamada.
  • loss_weighting_hidden_size (int, opcional, valor predeterminado 32) — Ancho del MLP que aprende la ponderación de incertidumbre de los términos de pérdida LSD a partir de sus tiempos de flujo (solo entrenamiento).
  • loss_weighting_num_layers (int, opcional, valor predeterminado 3) — Número de capas ocultas de ese MLP.

Esta es la clase de configuración para almacenar la configuración de un PocketTTSModel. Se utiliza para instanciar un modelo Pocket Tts según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de eustlb/pocket-tts

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

PocketTTSFeatureExtractor

clase 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, valor predeterminado 1) — El número de canales.
  • sampling_rate (int, opcional, valor predeterminado 24000) — La tasa de muestreo a la que se debe digitalizar la forma de onda de audio, expresada en hercios (Hz).
  • padding_value (float, opcional, valor predeterminado 0.0) — El valor que se utiliza para el relleno.
  • frame_size (int, opcional, valor predeterminado 1920) — Número de muestras de audio por marco latente del tokenizador de audio (su frame_size).
  • pad_to_multiple_of (int, opcional, valor predeterminado 1920) — Rellena el audio hasta un múltiplo de este valor; un múltiplo de frame_size mantiene cada cuadro latente completo.
  • end_on_pause (bool, opcional, valor predeterminado True) — Si se debe finalizar cada forma de onda con exactamente pause_duration segundos de silencio: se recorta el silencio final (los fotogramas de analysis_frame_duration segundos que están más de silence_floor_db por debajo del más fuerte), se aplica un fundido de salida a los últimos fade_out_duration segundos de lo que queda y se añaden pause_duration segundos de ceros.
  • pause_duration (float, opcional, valor predeterminado 0.08) — Duración del silencio que añade end_on_pause, en segundos.
  • fade_out_duration (float, opcional, valor predeterminado 0.02) — Duración del fundido a negro aplicado por end_on_pause antes de la pausa, en segundos.
  • silence_floor_db (float, opcional, valor predeterminado 35.0) — Nivel por debajo del cuadro de análisis más fuerte, en dB, por debajo del cual end_on_pause trata los cuadros finales como silencio.
  • analysis_frame_duration (float, opcional, valor predeterminado 0.02) — Duración de los fotogramas sobre los que end_on_pause mide el nivel, en segundos.

Construye un extractor de características de Pocket TTS, que prepara las formas de onda de los prompts de voz para el codificador del tokenizador de audio.

Cada forma de onda termina opcionalmente en una pausa breve (el end_on_pause original: los prompts de entrenamiento terminan dentro de la pausa entre dos palabras, un prompt que se detiene en el habla hace que el modelo la continúe y uno que termina en un silencio largo retrasa el inicio), y luego el lote se rellena a la derecha hasta un múltiplo del tamaño de cuadro del tokenizador.

__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]) — La forma de onda mono o el lote de formas de onda mono de los prompts de voz.
  • sampling_rate (int, opcional) — La tasa de muestreo a la que se muestreó la entrada de audio. Se recomienda encarecidamente pasar sampling_rate en la llamada de forward para evitar errores silenciosos.
  • end_on_pause (bool, opcional) — Si se termina cada forma de onda con una pausa breve, consulte la docstring de la clase. El valor predeterminado es self.end_on_pause.
  • padding (bool, str o PaddingStrategy, opcional, valor predeterminado True) — Estrategia de relleno del lote, consulte pad().
  • pad_to_multiple_of (int, opcional) — Rellena el lote hasta un múltiplo de este valor. El valor predeterminado es self.pad_to_multiple_of.

PocketTTSProcessor

clase 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) — El extractor de características es una entrada obligatoria.
  • tokenizer (TokenizersBackend) — El tokenizador es una entrada obligatoria.
  • audio_tokenizer (PocketTTSAudioTokenizerModel, opcional) — El códec: codifica el audio en latentes y decodifica los latentes generados en audio.
  • chat_template (str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.
  • short_text_max_words (int, opcional, valor predeterminado 4) — Los textos de como máximo esta cantidad de palabras reciben frames_after_eos_short_text fotogramas después del fotograma de fin de habla.
  • frames_after_eos_short_text (int, opcional, valor predeterminado 4) — Número de fotogramas generados después del fotograma de fin de habla para textos cortos.
  • frames_after_eos (int, opcional, valor predeterminado 2) — Número de fotogramas generados después del fotograma de fin de habla para textos más largos.
  • fade_in_duration (float, opcional, valor predeterminado 0.005) — Duración en segundos del fundido lineal de entrada aplicado al inicio de cada forma de onda decodificada: un estado de decodificador nuevo comienza con un pequeño paso, que se percibe como un clic.

Construye un PocketTTSProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

PocketTTSProcessor ofrece todas las funcionalidades de PocketTTSFeatureExtractor y TokenizersBackend. Consulte ~PocketTTSFeatureExtractor y ~TokenizersBackend para obtener más información.

__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 o list[str]) — El o los prompts renderizados por apply_chat_template().
  • audio (np.ndarray, torch.Tensor o una lista de estos, opcional) — Las formas de onda de las conversaciones, en mono a 24 kHz, en el orden de la conversación: cada voz y, en el entrenamiento, cada objetivo.
  • audio_prompt_latents (list[torch.Tensor], opcional) — Voces precalculadas, un tensor (num_frames, latent_dim) por marcador de posición de voz, en lugar de formas de onda.
  • labels (list[torch.Tensor], opcional) — Objetivos precalculados (entrenamiento), un tensor (num_frames, latent_dim) por marcador de posición de objetivo, en lugar de formas de onda.
  • end_on_pause (bool, kwargs, opcional) — Si se termina cada forma de onda de voz con una pausa breve, como hace el original antes de clonar una voz. Por defecto, usa el end_on_pause del extractor de características.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

split_text

< >

( text: strmax_tokens: int = 50 )

Parámetros

  • text (str) — El texto a dividir.
  • max_tokens (int, opcional, valor predeterminado 50) — Número máximo de tokens por bloque.

Divide text en fragmentos alineados con oraciones de como máximo max_tokens tokens, al igual que el método original split_into_best_sentences: el texto preparado se corta al final de las oraciones (no en puntos decimales), las oraciones más largas que max_tokens se cortan al final de las cláusulas y las piezas se agrupan de forma voraz. Cada fragmento está destinado a ser una conversación de un 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) o (num_frames, latent_dim)) — Los latentes que devuelve generate (PocketTTSGenerateOutput.audio_latents), decodificados como un solo lote, o los latentes de una muestra.
  • audio_latents_mask (torch.Tensor de forma (batch_size, num_frames), opcional) — Máscara de los fotogramas de cada muestra (PocketTTSGenerateOutput.audio_latents_mask). Sin ella, cada fila se decodifica a su longitud completa.

Decodifica los latentes generados en formas de onda con el tokenizador de audio y atenúa los primeros fade_in_duration segundos de cada una, tal como hace el 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 )

Escribe las formas de onda generadas en archivos WAV.

audio (torch.Tensor, np.ndarray o una lista de ellos): Las formas de onda, tal como las devuelve decode(). saving_path (str, Path o una lista de ellos): Una ruta por cada forma de onda. sampling_rate (int, opcional): Tasa de muestreo de las formas de onda, por defecto la del extractor de características (el tokenizador de audio).

PocketTTSModel

clase transformers.PocketTTSModel

< >

( config: PocketTTSConfig )

Parámetros

  • config (PocketTTSConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El backbone de Pocket TTS: un transformer causal sobre un único flujo compuesto por el prompt de voz, los tokens de texto y los latentes de audio, que devuelve los estados ocultos normalizados. El prompt de voz y los latentes de audio son latentes del tokenizador de audio, que el procesador mantiene.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • audio_prompt_latents (torch.Tensor de forma (batch_size, num_prompt_frames, latent_dim), opcional) — Latentes de la voz de referencia del tokenizador de audio (codificados por el procesador o por voices/ de un checkpoint), rellenados a la derecha hasta la longitud de la voz más larga del lote, distribuidos en las posiciones de audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forma (batch_size, num_prompt_frames), opcional) — Máscara de los fotogramas de voz (1) frente al relleno (0) en audio_prompt_latents.
  • audio_latents (torch.Tensor de forma (batch_size, num_latents, latent_dim), opcional) — Latentes de audio normalizados, distribuidos en las posiciones de audio_latent_token_id. La posición de audio_bos_token_id anterior a ellos, que cierra el prompt y desde la cual se genera el primer fotograma, siempre recibe el latente de BOS aprendido.
  • audio_latents_mask (torch.Tensor de forma (batch_size, num_latents), opcional) — Máscara de los latentes de cada fila (1) en contraposición al relleno (0) en audio_latents, cuando las filas contienen un número diferente de posiciones latentes (entrenamiento).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

Devuelve

BaseModelOutputWithPast o tuple(torch.Tensor)

Un BaseModelOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (PocketTTSConfig) y las entradas.

El método forward de PocketTTSModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

PocketTTSForConditionalGeneration

clase transformers.PocketTTSForConditionalGeneration

< >

( config: PocketTTSConfig )

Parámetros

  • config (PocketTTSConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo de texto a voz Pocket TTS: el backbone, la cabecera de flujo que muestrea un latente de audio por paso y la cabecera de fin de habla. Genera latentes del tokenizador de audio, que el procesador decodifica en audio de 24 kHz.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • audio_prompt_latents (torch.Tensor de forma (batch_size, num_prompt_frames, latent_dim), opcional) — Latentes de la voz de referencia del tokenizador de audio, rellenos a la derecha, distribuidos en las posiciones de audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forma (batch_size, num_prompt_frames), opcional) — Máscara de los fotogramas de voz (1) frente al relleno (0) en audio_prompt_latents.
  • audio_latents (torch.Tensor de forma (batch_size, num_latents, latent_dim), opcional) — Latentes de audio normalizados, distribuidos en las posiciones de audio_latent_token_id.
  • labels (torch.Tensor de forma (batch_size, num_frames, latent_dim), opcional) — Latentes objetivo del tokenizador de audio (entrenamiento), con relleno a la derecha. El prompt de cada fila termina en la posición audio_bos_token_id seguido de una posición audio_latent_token_id por cada frame: el modelo alimenta los objetivos normalizados (teacher forcing), aplica la pérdida de flujo a las salidas del BOS y de todos los frames excepto el último, que predicen los frames, y la pérdida de fin de habla a todos ellos, siendo el último el fin de la habla.
  • labels_mask (torch.Tensor de forma (batch_size, num_frames), opcional) — Máscara de los cuadros objetivo de cada fila (1) frente al relleno (0) en labels.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

Devuelve

PocketTTSOutputWithPast o tuple(torch.Tensor)

Un PocketTTSOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (PocketTTSConfig) y las entradas.

El método forward de PocketTTSForConditionalGeneration reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (), opcional, se devuelve cuando se pasa labels) — Pérdida de entrenamiento: la pérdida de flujo LSD de los latentes objetivo más config.eos_loss_weight veces la pérdida de fin de habla.

  • logits (torch.Tensor de forma (batch_size, sequence_length, 1)) — Logits de fin de habla, uno por posición.

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Estados ocultos normalizados del backbone, que condicionan la cabeza de flujo.

Ejemplo:

>>> 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) — Los input_ids preparados por PocketTTSProcessor. También se pueden pasar como input_ids=.
  • kwargs (dict[str, Any], opcional) — attention_mask, el prompt de voz (audio_prompt_latents y audio_prompt_latents_mask, o la caché de un prefijo de voz como past_key_values, las voces incluidas, con prompts solo de texto), frames_after_eos del procesador, los parámetros de generación (do_sample, temperature, max_new_tokens, …) y los específicos de Pocket TTS num_flow_steps, eos_threshold y min_frames_before_eos, que por defecto se toman de la configuración de generación.

Genera audio. Este método sobrescribe generate() para establecer max_new_tokens por defecto en el presupuesto de fotogramas del tiempo de ejecución original, ceil((num_text_tokens / 3 + 2) * frame_rate) para el texto más largo del lote. Todo lo demás pasa por los hooks de generación habituales.

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 del backbone de la posición que se está generando.
  • noise (torch.Tensor de forma (batch_size, latent_dim)) — Ruido gaussiano escalado por sqrt(temperature), o ceros.
  • num_flow_steps (int) — Número de pasos de Euler del muestreador LSD (ignorado por la cabeza de deriva, que realiza una sola llamada).

Devuelve

torch.Tensor de forma (batch_size, latent_dim)

el latente muestreado, en el espacio normalizado.

Muestrea el siguiente latente desde noise con la cabeza de flujo.

denormalize_latents

< >

( audio_latents: Tensor )

Mapea los latentes del espacio normalizado de la cabeza de flujo al del tokenizador de audio.

PocketTTSGenerateOutput

clase 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)) — Los ids de tokens del prompt seguidos de un audio_latent_token_id por cada frame generado. El audio en sí está en audio_latents.
  • scores (tuple(torch.Tensor) opcional, se devuelve cuando output_scores=True) — El logit de fin de habla de cada cuadro generado, un tensor de forma (batch_size,) por cuadro.
  • logits (tuple(torch.Tensor) opcional, se devuelve cuando output_logits=True) — Igual que scores: Pocket TTS no tiene vocabulario, por lo que no hay nada que procesar entre ambos.
  • attentions (tuple(tuple(torch.Tensor)), opcional, se devuelve cuando output_attentions=True) — Tupla (un elemento por cada cuadro generado) de tuplas (un elemento por cada capa) de torch.Tensor de forma (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(torch.Tensor)), opcional, devuelto cuando output_hidden_states=True) — Tupla (un elemento por cada cuadro generado) de tuplas (un elemento por cada capa) de torch.Tensor de forma (batch_size, generated_length, hidden_size).
  • past_key_values (Cache, opcional, se devuelve cuando use_cache=True) — La caché de claves/valores del backbone al final de la generación.
  • audio_latents (torch.Tensor de forma (batch_size, num_frames, latent_dim)) — Los latentes generados, en el espacio latente del tokenizador de audio, rellenos a la derecha con ceros más allá de los propios frames de cada muestra. PocketTTSProcessor.decode() los convierte en formas de onda.
  • audio_latents_mask (torch.LongTensor de forma (batch_size, num_frames)) — Máscara de los fotogramas de cada muestra (1), incluido el fotograma de fin de habla y los fotogramas posteriores, en contraposición al relleno (0).

Salidas de PocketTTSForConditionalGeneration.generate.

Update on GitHub

←PE Audio Pocket TTS Audio Tokenizer→