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.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2026-10-20.

Pocket TTS

Aperçu

Pocket TTS est le modèle de synthèse vocale de 100 millions de paramètres de Kyutai, un Continuous Audio Language Model qui s’exécute plus vite que le temps réel sur CPU. Un transformer causal émet un latent audio continu par frame (12,5 Hz) via une tête de flux à une étape, et une tête de fin de parole décide quand s’arrêter.

Le processeur contient le tokeniseur audio Pocket TTS, un codec basé sur Mimi qui encode les invites vocales et décode les latents générés en audio 24 kHz. Les voix prédéfinies sont fournies sous forme de caches KV (voices/).

Deux têtes de flux sont publiées : auto-distillation lagrangienne (flow_type="lsd", par défaut) et dérive (flow_type="drifting", english_drifting_26-09). Le fine-tuning est pris en charge, voir Entraînement.

Ce modèle a été contribué par Eustache Le Bihan. Le code original est kyutai-labs/pocket-tts.

Conseils d'utilisation

  • Préparez les entrées avec apply_chat_template() (un message user par texte, add_generation_prompt=True). Le normalisateur du tokenizer prépare le texte comme l’original, avec les paramètres de la langue du checkpoint.
  • generate renvoie audio_latents et audio_latents_mask ; décodez-les avec PocketTTSProcessor.decode().
  • max_new_tokens est par défaut basé sur un budget fonction de la longueur du texte, et la génération s’arrête peu après que le logit de fin de parole dépasse eos_threshold.
  • do_sample=False correspond à l’original à température 0. Avec l’échantillonnage, temperature (valeur par défaut 0,3) est la variance du bruit initial du flux.
  • Découpez le long texte avec PocketTTSProcessor.split_text(), une conversation par fragment.

Utilisation

Voix

La voix peut être fournie de trois manières.

1. Clonage d'un enregistrement : un élément audio dans la conversation.

from transformers import AutoModelForTextToWaveform, AutoProcessor

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

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

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

2. Latents précalculés : un élément audio vide, avec les latents transmis au processeur.

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. Contexte mis en cache : le cache KV du prompt vocal, transmis sous forme de past_key_values. Les voix fournies (voices/) utilisent cette forme.

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

Lots et texte long

Traitez plusieurs textes et voix par lot, avec le texte long découpé en segments :

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

Point de contrôle dérivant

Même utilisation, avec les voix propres au point de contrôle :

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

Entraînement

Placez l’audio cible dans le tour assistant. Le processeur renvoie ses latents en tant que labels, et le modèle renvoie la perte de l’original (perte de flux LSD plus config.eos_loss_weight fois la perte de fin de parole). L’invite vocale est généralement le début de la même énonciation.

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()
  • Fournissez la voix sous forme d'enregistrement ou de latents, et non de cache.
  • Pour le guidage sans classifieur, supprimez l'élément audio ou text du tour user (l'original supprime chacun avec une probabilité de 0,2).
  • Les latents précalculés sont passés dans processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}, avec des éléments vides {"type": "audio"} en guise de placeholders.
  • Recette d'origine : AdamW, learning_rate=2e-5 (2e-4 pour une nouvelle langue), adam_beta2=0.95, weight_decay=0.1, max_grad_norm=1.0, 1000 étapes de montée en température puis constante, EMA des poids (décroissance 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 )

Paramètres

  • flow_head_config (Union[PocketTTSFlowHeadConfig, dict], facultatif) — La configuration de la tête de flux qui échantillonne chaque latent à partir de l'état caché du backbone.
  • vocab_size (int, facultatif, par défaut 4004) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 6) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_key_value_heads (int, facultatif) — Ceci est le nombre de têtes key_value à utiliser pour implémenter la Grouped Query Attention. Si num_key_value_heads=num_attention_heads, le modèle utilisera la Multi Head Attention (MHA), si num_key_value_heads=1 le modèle utilisera la Multi Query Attention (MQA), sinon la GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite par moyennage (meanpooling) de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut est num_attention_heads.
  • head_dim (int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
  • intermediate_size (int, facultatif, par défaut 4096) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut gelu_pytorch_tanh) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — Epsilon des normalisations de couche du backbone.
  • attention_bias (bool, facultatif, par défaut False) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention.
  • attention_dropout (float, facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • max_position_embeddings (int, facultatif, par défaut 8192) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.
  • latent_dim (int, facultatif, valeur par défaut 32) — Dimension des latents audio que le backbone reçoit en entrée (audio_prompt_latents, audio_latents) ; égale à la latent_dim de la tête de flux et du tokenizer audio.
  • pad_token_id (int, facultatif, par défaut 3) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (int, facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • audio_prompt_token_id (int, facultatif, valeur par défaut 4000) — Identifiant du jeton de remplacement pour les trames de l’invite vocale dans input_ids.
  • audio_latent_token_id (int, facultatif, valeur par défaut 4001) — Identifiant du jeton de remplacement pour les positions latentes audio dans input_ids.
  • audio_prompt_bos_token_id (int, facultatif, valeur par défaut 4002) — Identifiant du jeton placé avant le prompt vocal ; son embedding est le vecteur appris que l’original préfixe au vocal.
  • audio_bos_token_id (int, facultatif, valeur par défaut 4003) — Identifiant du jeton de la première position audio, qui clôt le prompt : il contient le latent BOS appris, à partir duquel la première image est générée.
  • frame_rate (float, facultatif, valeur par défaut 12.5) — Nombre de latents audio par seconde d'audio : generate en dérive son budget de trames par défaut.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • eos_loss_weight (float, facultatif, valeur par défaut 0.1) — Poids de la perte de fin de parole dans la perte d'entraînement.
  • flow_loss_num_samples (int, facultatif, valeur par défaut : 4) — Nombre de tirages de bruit par image cible dans la perte de flux.
  • lsd_distill_probability (float, facultatif, valeur par défaut 0.25) — Probabilité, à chaque étape d'entraînement, de calculer le terme d'auto-distillation de la perte LSD (répondant à une perte attendue constante) ; 1 le calcule à chaque étape.
  • lsd_diagonal_weight (float, facultatif, valeur par défaut 0,75) — Poids du terme diagonal (flux instantané) de la perte LSD ; le terme d'auto-distillation pondère le reste.
  • lsd_time_logit_mean (float, facultatif, valeur par défaut 0.4) — Moyenne de la distribution logit-normale des temps de flux tirés par la perte LSD.
  • lsd_time_logit_std (float, facultatif, valeur par défaut 1.0) — Écart-type de la distribution logit-normale des temps de flux tirés par la perte LSD.
  • latent_stats_ema_steps (int, facultatif, valeur par défaut 1000) — Nombre de premières étapes d’entraînement pendant lesquelles latent_mean et latent_std suivent une moyenne mobile exponentielle des latents cibles ; 0 les maintient figés.
  • latent_stats_ema_decay (float, facultatif, valeur par défaut 0.999) — Taux d'amortissement de cette moyenne mobile.

Ceci est la classe de configuration destinée à stocker la configuration d'un PocketTTSModel. Elle est utilisée pour instancier un modèle Pocket Tts en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de eustlb/pocket-tts

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

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 )

Paramètres

  • hidden_size (int, facultatif, par défaut 512) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 6) — Nombre de couches cachées dans le décodeur Transformer.
  • latent_dim (int, facultatif, valeur par défaut 32) — Dimension des latents audio continus prédits par la tête (la dimension latente du tokenizer audio).
  • condition_dim (int, facultatif, valeur par défaut 1024) — Dimension de l'état caché du backbone sur lequel la tête est conditionnée (le hidden_size du backbone).
  • frequency_embedding_size (int, facultatif, valeur par défaut 256) — Taille de l’encodage sinusoïdal des temps de flux.
  • hidden_act (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — Epsilon des normalisations de couche dans les blocs résiduels et la couche finale.
  • rms_norm_eps (float, facultatif, valeur par défaut 1e-05) — Epsilon de la normalisation fermant les embeddings temporels.
  • max_period (float, facultatif, valeur par défaut 10000.0) — Période maximale de l’encodage temporel sinusoïdal, que le point de contrôle stocke sous la forme de freqs.
  • flow_type (str, facultatif, par défaut "lsd") — Objectif avec lequel la tête a été entraînée, qui définit sa façon d’être conditionnée et échantillonnée. "lsd" (auto-distillation lagrangienne) : conditionnée sur les temps de début et de fin d’une étape de flux, échantillonnée par étapes d’Euler à partir d’un bruit gaussien. "drifting" : aucune condition temporelle, la tête mappe le bruit vers le latent en un seul appel.
  • loss_weighting_hidden_size (int, facultatif, valeur par défaut 32) — Largeur du MLP qui apprend le pondération de l'incertitude des termes de perte LSD à partir de leurs temps de flux (entraînement uniquement).
  • loss_weighting_num_layers (int, facultatif, valeur par défaut 3) — Nombre de couches cachées de ce MLP.

Ceci est la classe de configuration destinée à stocker la configuration d'un PocketTTSModel. Elle est utilisée pour instancier un modèle Pocket Tts en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de eustlb/pocket-tts

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

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 )

Paramètres

  • feature_size (int, facultatif, valeur par défaut 1) — Le nombre de canaux.
  • sampling_rate (int, facultatif, par défaut 24000) — La fréquence d'échantillonnage à laquelle la forme d'onde audio doit être numérisée, exprimée en hertz (Hz).
  • padding_value (float, facultatif, par défaut 0.0) — La valeur utilisée pour le bourrage.
  • frame_size (int, facultatif, valeur par défaut 1920) — Nombre d'échantillons audio par trame latente du tokeniseur audio (sa frame_size).
  • pad_to_multiple_of (int, facultatif, valeur par défaut 1920) — Remplit l'audio jusqu'à un multiple de cette valeur ; un multiple de frame_size garantit que chaque trame latente reste entière.
  • end_on_pause (bool, facultatif, valeur par défaut True) — Indique s'il faut terminer chaque forme d'onde exactement sur pause_duration secondes de silence : le silence de fin (les trames de analysis_frame_duration secondes inférieures de plus de silence_floor_db à la plus forte) est coupé, les fade_out_duration dernières secondes de ce qui reste sont atténuées, et pause_duration secondes de zéros sont ajoutées.
  • pause_duration (float, facultatif, par défaut 0.08) — Durée du silence ajouté par end_on_pause, en secondes.
  • fade_out_duration (float, facultatif, valeur par défaut 0.02) — Durée de la fondu de sortie appliqué par end_on_pause avant la pause, en secondes.
  • silence_floor_db (float, facultatif, valeur par défaut 35.0) — Niveau sous la trame d’analyse la plus forte, en dB, en dessous duquel end_on_pause considère les trames finales comme du silence.
  • analysis_frame_duration (float, facultatif, valeur par défaut 0.02) — Durée des trames sur lesquelles end_on_pause mesure le niveau, en secondes.

Construit un extracteur de fonctionnalités Pocket TTS, qui prépare les formes d’onde des prompts vocaux pour l’encodeur du tokeniseur audio.

Chaque forme d’onde se termine éventuellement par une courte pause (le end_on_pause d’origine : les prompts d’entraînement se terminent à l’intérieur de la pause entre deux mots, un prompt qui s’arrête sur de la parole amène le modèle à la poursuivre et un prompt qui se termine sur un long silence retarde l’attaque), puis le lot est complété à droite jusqu’à un multiple de la taille de trame du 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 )

Paramètres

  • audio (np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — La forme d’onde mono ou le lot de formes d’onde mono des prompts vocaux.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle l’entrée audio a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l’appel forward afin d’éviter les erreurs silencieuses.
  • end_on_pause (bool, facultatif) — Indique s'il faut terminer chaque forme d'onde par une courte pause, voir la docstring de la classe. Valeur par défaut : self.end_on_pause.
  • padding (bool, str ou PaddingStrategy, facultatif, par défaut True) — Stratégie de bourrage du lot, voir pad().
  • pad_to_multiple_of (int, facultatif) — Remplit le lot jusqu'à un multiple de cette valeur. Par défaut, 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 )

Paramètres

  • feature_extractor (PocketTTSFeatureExtractor) — L’extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (TokenizersBackend) — Le tokenizer est une entrée obligatoire.
  • audio_tokenizer (PocketTTSAudioTokenizerModel, facultatif) — Le codec : il encode l’audio en latents et décode les latents générés en audio.
  • chat_template (str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.
  • short_text_max_words (int, facultatif, valeur par défaut : 4) — Les textes de moins de ce nombre de mots reçoivent frames_after_eos_short_text trames après la trame de fin de parole.
  • frames_after_eos_short_text (int, facultatif, valeur par défaut : 4) — Nombre de frames générées après la frame de fin de parole pour les textes courts.
  • frames_after_eos (int, facultatif, valeur par défaut : 2) — Nombre de frames générées après la frame de fin de parole pour les textes plus longs.
  • fade_in_duration (float, facultatif, valeur par défaut 0.005) — Durée en secondes du fondu linéaire appliqué au début de chaque forme d’onde décodée : un nouvel état de décodeur démarre avec une petite étape, perçue comme un clic.

Construit un PocketTTSProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

PocketTTSProcessor offre toutes les fonctionnalités de PocketTTSFeatureExtractor et de TokenizersBackend. Consultez ~PocketTTSFeatureExtractor et ~TokenizersBackend pour plus d’informations.

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

Paramètres

  • text (str ou list[str]) — Le(s) prompt(s) rendu(s) par apply_chat_template().
  • audio (np.ndarray, torch.Tensor ou une liste de ceux-ci, facultatif) — Les formes d’onde des conversations, en mono à 24 kHz, dans l’ordre de la conversation : chaque voix, et, lors de l’entraînement, chaque cible.
  • audio_prompt_latents (list[torch.Tensor], facultatif) — Voix précalculées, un tenseur (num_frames, latent_dim) par emplacement de voix, au lieu des formes d’onde.
  • labels (list[torch.Tensor], facultatif) — Cibles précalculées (entraînement), un tenseur (num_frames, latent_dim) par emplacement de cible, au lieu des formes d’onde.
  • end_on_pause (bool, kwargs, facultatif) — Indique s'il faut terminer chaque forme d'onde de prompt vocal par une courte pause, comme le fait l'original avant de cloner une voix. Valeur par défaut : end_on_pause de l'extracteur de caractéristiques.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

split_text

< >

( text: strmax_tokens: int = 50 )

Paramètres

  • text (str) — Le texte à diviser.
  • max_tokens (int, facultatif, valeur par défaut 50) — Nombre maximal de jetons par bloc.

Découpe text en segments alignés sur les phrases, d’au plus max_tokens jetons, comme le fait split_into_best_sentences de l’original : le texte préparé est coupé après la fin des phrases (et non sur les points décimaux), les phrases plus longues que max_tokens après la fin des clauses, et les morceaux sont regroupés de manière gloutonne. Chaque segment est destiné à constituer une conversation d’un lot.

décoder

< >

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

Paramètres

  • audio_latents (torch.Tensor de forme (batch_size, num_frames, latent_dim) ou (num_frames, latent_dim)) — Les latents que generate renvoie (PocketTTSGenerateOutput.audio_latents), décodés en tant qu’un seul lot, ou les latents d’un seul échantillon.
  • audio_latents_mask (torch.Tensor de forme (batch_size, num_frames), facultatif) — Masque des frames de chaque échantillon (PocketTTSGenerateOutput.audio_latents_mask). Sans lui, chaque ligne est décodée sur sa longueur complète.

Décode les latents générés en formes d’onde à l’aide du tokeniseur audio et applique un fondu d’entrée sur les fade_in_duration premières secondes de chaque segment, comme dans l’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 )

Écrit les formes d'onde générées dans des fichiers WAV.

audio (torch.Tensor, np.ndarray ou une liste de ceux-ci) : Les formes d’onde, telles que renvoyées par decode(). saving_path (str, Path ou une liste de ceux-ci) : Un chemin par forme d’onde. sampling_rate (int, facultatif) : Taux d’échantillonnage des formes d’onde, par défaut celui de l’extracteur de caractéristiques (du tokeniseur audio).

PocketTTSModel

classe transformers.PocketTTSModel

< >

( config: PocketTTSConfig )

Paramètres

  • config (PocketTTSConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le backbone Pocket TTS : un transformer causal sur un flux unique composé du prompt vocal, des jetons de texte et des latents audio, renvoyant les états cachés normalisés. Le prompt vocal et les latents audio sont des latents du tokenizer audio, que le processeur détient.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

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)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • audio_prompt_latents (torch.Tensor de forme (batch_size, num_prompt_frames, latent_dim), facultatif) — Latents du prompt vocal du tokenizer audio (encodés par le processeur, ou par le dossier voices/ d’un point de contrôle), remplis à droite jusqu’à la longueur de la voix la plus longue du lot, dispersés aux positions audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forme (batch_size, num_prompt_frames), facultatif) — Masque des trames vocales (1) par opposition au bourrage (0) dans audio_prompt_latents.
  • audio_latents (torch.Tensor de forme (batch_size, num_latents, latent_dim), facultatif) — Latents audio normalisés, dispersés dans les positions audio_latent_token_id. La position audio_bos_token_id qui les précède, et qui clôt le prompt et à partir de laquelle la première image est générée, reçoit toujours le latent BOS appris.
  • audio_latents_mask (torch.Tensor de forme (batch_size, num_latents), facultatif) — Masque des latents de chaque ligne (1) par opposition au bourrage (0) dans audio_latents, lorsque les lignes contiennent des nombres différents de positions latentes (entraînement).
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

BaseModelOutputWithPast ou tuple(torch.Tensor)

Un BaseModelOutputWithPast ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PocketTTSConfig) et des entrées.

La méthode forward du modèle PocketTTSModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

    Si past_key_values est utilisé, seule la dernière hidden-state des séquences de forme (batch_size, 1, hidden_size) est renvoyée.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si config.is_encoder_decoder=True, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

PocketTTSForConditionalGeneration

classe transformers.PocketTTSForConditionalGeneration

< >

( config: PocketTTSConfig )

Paramètres

  • config (PocketTTSConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle de synthèse vocale Pocket TTS : le tronc, la tête de flux qui échantillonne un latent audio par étape et la tête de fin de parole. Il génère des latents du tokeniseur audio, que le processeur décode en audio 24 kHz.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

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)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • audio_prompt_latents (torch.Tensor de forme (batch_size, num_prompt_frames, latent_dim), facultatif) — Latents du prompt vocal du tokenizer audio, complétés à droite, dispersés dans les positions audio_prompt_token_id.
  • audio_prompt_latents_mask (torch.Tensor de forme (batch_size, num_prompt_frames), facultatif) — Masque des trames vocales (1) par opposition au bourrage (0) dans audio_prompt_latents.
  • audio_latents (torch.Tensor de forme (batch_size, num_latents, latent_dim), facultatif) — Latents audio normalisés, dispersés dans les positions audio_latent_token_id.
  • labels (torch.Tensor de forme (batch_size, num_frames, latent_dim), facultatif) — Latents cibles du tokenizer audio (entraînement), avec remplissage à droite. La fin du prompt de chaque ligne est constituée de la position audio_bos_token_id suivie d’une position audio_latent_token_id par frame : le modèle alimente les cibles normalisées (teacher forcing), applique la perte de flux aux sorties du BOS et de toutes les frames sauf la dernière, qui prédisent les frames, et la perte de fin de parole à toutes, la dernière étant la fin de parole.
  • labels_mask (torch.Tensor de forme (batch_size, num_frames), facultatif) — Masque des cibles de chaque ligne (1) par opposition au bourrage (0) dans labels.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

PocketTTSOutputWithPast ou tuple(torch.Tensor)

Un PocketTTSOutputWithPast ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PocketTTSConfig) et des entrées.

La méthode forward de PocketTTSForConditionalGeneration redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (), facultatif, renvoyé lorsque labels est passé) — Perte d’entraînement : la perte de flux LSD des latents cibles plus config.eos_loss_weight fois la perte de fin de parole.

  • logits (torch.Tensor de forme (batch_size, sequence_length, 1)) — Logits de fin de parole, un par position.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — États cachés normalisés du backbone, qui conditionnent la tête de flux.

Exemple :

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

Paramètres

  • inputs (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Les input_ids préparés par PocketTTSProcessor. Peut également être transmis sous la forme input_ids=.
  • kwargs (dict[str, Any], facultatif) — attention_mask, le prompt vocal (audio_prompt_latents et audio_prompt_latents_mask, ou le cache d'un préfixe vocal sous forme de past_key_values, les voix livrées, avec des prompts du texte uniquement), frames_after_eos du processeur, les paramètres de génération (do_sample, temperature, max_new_tokens, …), ainsi que les paramètres spécifiques à Pocket TTS num_flow_steps, eos_threshold et min_frames_before_eos, qui par défaut correspondent à la configuration de génération.

Génère de la parole. Cette méthode redéfinit generate() pour définir max_new_tokens par défaut sur le budget de frames du temps d’exécution d’origine, soit ceil((num_text_tokens / 3 + 2) * frame_rate) pour le texte le plus long du lot. Le reste passe par les hooks de génération habituels.

sample_latent

< >

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

Paramètres

  • condition (torch.Tensor de forme (batch_size, hidden_size)) — État caché du backbone de la position en cours de génération.
  • noise (torch.Tensor de forme (batch_size, latent_dim)) — Bruit gaussien mis à l'échelle par sqrt(temperature), ou zéros.
  • num_flow_steps (int) — Nombre d'étapes d'Euler de l'échantillonneur LSD (ignoré par la tête dérivante, qui n'effectue qu'un seul appel).

Retourne

torch.Tensor de forme (batch_size, latent_dim)

le latent échantillonné, dans l'espace normalisé.

Échantillonne le latent suivant à partir de noise avec la tête de flux.

denormalize_latents

< >

( audio_latents: Tensor )

Cartographie des espaces latents de l'espace normalisé de la tête de flux vers celui du tokenizer audio.

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 )

Paramètres

  • sequences (torch.LongTensor de forme (batch_size, sequence_length)) — Les identifiants de jetons du prompt suivis d'un audio_latent_token_id par trame générée. L'audio lui-même se trouve dans audio_latents.
  • scores (tuple(torch.Tensor) facultatif, renvoyé lorsque output_scores=True) — Le logit de fin de parole de chaque frame générée, un tenseur de forme (batch_size,) par frame.
  • logits (tuple(torch.Tensor) facultatif, renvoyé lorsque output_logits=True) — Identique à scores : Pocket TTS ne possède pas de vocabulaire, il n’y a donc rien à traiter entre les deux.
  • attentions (tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsque output_attentions=True) — Tuplet (un élément pour chaque frame généré) de tuplets (un élément pour chaque couche) de torch.Tensor de forme (batch_size, num_heads, generated_length, sequence_length).
  • hidden_states (tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsque output_hidden_states=True) — Tuple (un élément pour chaque image générée) de tuples (un élément pour chaque couche) de torch.Tensor de forme (batch_size, generated_length, hidden_size).
  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True) — Le cache des clés/valeurs du backbone à la fin de la génération.
  • audio_latents (torch.Tensor de forme (batch_size, num_frames, latent_dim)) — Les latents générés, dans l’espace latent du tokenizer audio, complétés à droite par des zéros au-delà des propres frames de chaque échantillon. PocketTTSProcessor.decode() les convertit en formes d’onde.
  • audio_latents_mask (torch.LongTensor de forme (batch_size, num_frames)) — Masque des trames de chaque exemple (1), incluant la trame de fin de parole et les trames qui la suivent, par opposition au bourrage (0).

Sorties de PocketTTSForConditionalGeneration.generate.

Update on GitHub

←PE Audio Pocket TTS Audio Tokenizer→