Hugging Face's logo

Transformers documentation

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

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

Gradium Phonon TTS

Aperçu

Gradium Phonon TTS est la famille de modèles de synthèse vocale sur appareil de Gradium, entraînée selon la recette de Pocket TTS : un transformer causal lit un prompt vocal et le texte, puis émet un latent audio continu de 32 dimensions à chaque étape, à 12,5 Hz, via une tête de flux à une étape, et une tête de fin de parole décide quand l’énoncé est terminé. Les latents sont décodés en audio 24 kHz par un Pocket TTS audio tokenizer détenu par le processeur, le PocketTTSProcessor de Pocket TTS.

Il se distingue de Pocket TTS par son conditionnement vocal : le prompt vocal est constitué de latents de dimension 512 issus d'un codec de locuteur distinct, et un vecteur de locuteur appris est ajouté à chaque position latente audio. Le codec de locuteur n'étant pas publié, les voix sont fournies sous forme de latents précalculés (le fichier default-voice.safetensors de chaque point de contrôle, ainsi que le catalogue de gradium/phonon-voices) et le tokenizer audio est un décodeur uniquement : il est impossible de cloner une voix à partir d'un enregistrement.

Point de contrôleParamètresLanguesLicence
gradium/phonon-31m-en31MAnglaisApache 2.0
gradium/phonon-40m-en40MAnglaisCC BY-NC 4.0
gradium/phonon-40m-fr40MFrenchCC BY-NC 4.0
gradium/phonon-40m-de40MAllemandCC BY-NC 4.0
gradium/phonon-40m-es40MEspagnolCC BY-NC 4.0
gradium/phonon-40m-pt40MPortugaisCC BY-NC 4.0
gradium/phonon-40m-multilingual40MAnglais, français, allemand, espagnol, portugaisCC BY-NC 4.0

Ils se chargent tous de la même manière : changer de point de contrôle revient à changer l’identifiant du dépôt.

Ce modèle a été contribué par Eustache Le Bihan. Le code d'origine est gradium-ai/xn-ptts.

Conseils d'utilisation

  • Préparez les entrées avec apply_chat_template() : un message user par texte, un élément vide {"type": "audio"} à l’endroit où se trouve la voix, les latents de la voix dans processor_kwargs={"audio_prompt_latents": [...]}, et add_generation_prompt=True.
  • Le tokenizer n'écrit pas les nombres, les montants, les symboles ou les adresses en toutes lettres, voir Normalisation du texte.
  • generate renvoie audio_latents et audio_latents_mask ; décodez-les avec PocketTTSProcessor.decode().
  • Génère des échantillons comme le fait le runtime de Gradium : temperature 0,3 (la variance du bruit initial du flux), et s’arrête peu après que le logit de fin de parole dépasse eos_threshold. do_sample=False démarre le flux à partir d’un bruit nul.
  • Le modèle est chargé en bf16, le dtype dans lequel ses poids sont stockés ; passez dtype=torch.float32 sur CPU pour correspondre au runtime de Gradium sur cette plateforme.
  • Découpez le long texte avec PocketTTSProcessor.split_text(), une conversation par fragment.

Utilisation

Voix

Une voix est un tenseur de latents (num_frames, 512). Chaque checkpoint en fournit un (default-voice.safetensors), et gradium/phonon-voices en propose environ une centaine de plus, dans toutes les langues, chacune sous son identifiant de voix (voices.jsonl répertorie leurs noms, langues et descriptions). Toute voix fonctionne avec n’importe quel checkpoint.

import torch
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoProcessor, GradiumPhononTTSForConditionalGeneration

model_id = "gradium/phonon-31m-en"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = GradiumPhononTTSForConditionalGeneration.from_pretrained(model_id, device_map="auto")


def load_voice(voice_id):
    """A voice of gradium/phonon-voices, as latents of shape (num_frames, 512)."""
    path = hf_hub_download("gradium/phonon-voices", f"voices/{voice_id}.safetensors")
    return load_file(path)["speaker_wavs"][0].T.float()


# Easton (en-us); the checkpoint's own voice: hf_hub_download(model_id, "default-voice.safetensors")
voice = load_voice("LMDIYE0Oa377Qh6Z")
# an empty `audio` item marks the voice
conversation = [
    {"role": "user", "content": [{"type": "audio"}, {"type": "text", "text": "Hello from Phonon."}]}
]
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, "phonon.wav")

Lots et texte long

Traiter par lots plusieurs textes, chacun avec sa propre voix, en découpant les longs textes en segments :

text = (
    "Phonon is a small text-to-speech model that runs on your device. "
    "Long texts are split into sentences, and each chunk is one conversation of the batch."
)
chunks = processor.split_text(text)
texts = chunks + ["And this one is said by another voice."]
voices = [load_voice("LMDIYE0Oa377Qh6Z")] * len(chunks) + [load_voice("NbpkqMVS3CJeq2j8")]
conversations = [
    [{"role": "user", "content": [{"type": "audio"}, {"type": "text", "text": text}]}] for text in texts
]
inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    return_dict=True,
    add_generation_prompt=True,
    processor_kwargs={"audio_prompt_latents": voices},
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio([torch.cat(audio[: len(chunks)]), audio[-1]], ["long.wav", "other.wav"])

Normalisation du texte

Le tokenizer normalise ce qui ne dépend pas de la langue, tout comme le runtime de Gradium :

TexteTokenizer
“Hello” — it’s here…"Hello" it's here.
hello (world); see you 🚀Hello, world, see you.

Il ne prononce pas les nombres, les montants, les symboles ou les adresses, qui dépendent de la langue :

TexteTokenizerLe runtime de Gradium
It costs $1,234.56.It costs $1,234.56.It costs 1 thousand 234 dollars and 56 cents.
Write to jean@gradium.aiWrite to jean@gradium.ai.Write to jean at gradium dot A-I.
It is 21°CIt is 21°C.It is 21 degrees Celsius.

Pour ceux-ci, utilisez la normalisation du texte du runtime de Gradium, ptts, ou écrivez-les en toutes lettres.

GradiumPhononTTSConfig

classe transformers.GradiumPhononTTSConfig

< >

( 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 = 4001hidden_size: int = 768num_hidden_layers: int = 6num_attention_heads: int = 12num_key_value_heads: int | None = Nonehead_dim: int | None = Noneintermediate_size: int = 3072hidden_act: str = 'gelu'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 = 5audio_latent_token_id: int = 6audio_bos_token_id: int = 4frame_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.999audio_prompt_dim: int = 512num_speakers: int = 1num_speakers_vocab_size: int = 32num_speakers_embedding_dim: int = 16duration_delta: float = 0.0duration_delta_embedding_dim: int = 128duration_delta_scale: float = 1000.0duration_delta_max_period: float = 10000.0 )

Paramètres

  • flow_head_config (Union[GradiumPhononTTSFlowHeadConfig, 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 4001) — 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 768) — 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 12) — 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 3072) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut gelu) — 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_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 5) — Identifiant du jeton de remplacement pour les trames de l’invite vocale dans input_ids (<|audio_prompt|>).
  • audio_latent_token_id (int, facultatif, valeur par défaut 6) — Identifiant du jeton de remplacement des positions latentes audio dans input_ids (<|audio_latent|>).
  • audio_bos_token_id (int, facultatif, valeur par défaut 4) — 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 trame est générée (<|audio_bos|>).
  • 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.
  • audio_prompt_dim (int, facultatif, valeur par défaut 512) — Dimension des latents de l’invite vocale (audio_prompt_latents), les latents non quantifiés du codec de locuteur de Gradium (un encodeur Mimi, et non celui du tokeniseur audio), que le backbone projette vers hidden_size.
  • num_speakers (int, facultatif, par défaut 1) — Valeur de la condition num_speakers : la ligne de sa table de recherche ajoutée à chaque position latente audio.
  • num_speakers_vocab_size (int, facultatif, valeur par défaut 32) — Nombre de lignes de la table de recherche num_speakers.
  • num_speakers_embedding_dim (int, facultatif, valeur par défaut 16) — Largeur de la table de recherche num_speakers, projetée sur hidden_size.
  • duration_delta (float, facultatif, valeur par défaut 0.0) — Valeur de la condition duration_delta, intégrée de manière sinusoïdale et ajoutée à chaque position latente audio.
  • duration_delta_embedding_dim (int, facultatif, valeur par défaut 128) — Taille de l'embedding sinusoïdal de duration_delta, projeté sur hidden_size.
  • duration_delta_scale (float, facultatif, valeur par défaut 1000.0) — Facteur appliqué à duration_delta avant son encodage sinusoïdal.
  • duration_delta_max_period (float, facultatif, valeur par défaut 10000.0) — Période maximale de l’encodage sinusoïdal de duration_delta.

Ceci est la classe de configuration destinée à stocker la configuration d'un GradiumPhononTTSModel. Elle est utilisée pour instancier un modèle Gradium Phonon 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 du gradium/phonon-31m-en

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.

GradiumPhononTTSFlowHeadConfig

classe transformers.GradiumPhononTTSFlowHeadConfig

< >

( 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 = 768frequency_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, par défaut 768) — 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 GradiumPhononTTSModel. Elle est utilisée pour instancier un modèle Gradium Phonon 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 du gradium/phonon-31m-en

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.

GradiumPhononTTSModel

classe transformers.GradiumPhononTTSModel

< >

( config: GradiumPhononTTSConfig )

Paramètres

  • config (GradiumPhononTTSConfig) — 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 Gradium Phonon TTS : un transformer causal sur un flux unique composé du prompt vocal (latents du codec de la voix), des jetons de texte et des latents audio, renvoyant les états cachés normalisés.

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 (GradiumPhononTTSConfig) et des entrées.

La méthode forward du GradiumPhononTTSModel 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.

GradiumPhononTTSForConditionalGeneration

classe transformers.GradiumPhononTTSForConditionalGeneration

< >

( config: GradiumPhononTTSConfig )

Paramètres

  • config (GradiumPhononTTSConfig) — 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 Gradium Phonon TTS : le tronc commun, la tête de flux qui échantillonne un latent audio à chaque é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'> ) → GradiumPhononTTSOutputWithPast 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

GradiumPhononTTSOutputWithPast ou tuple(torch.Tensor)

Un GradiumPhononTTSOutputWithPast 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 (GradiumPhononTTSConfig) et des entrées.

La méthode forward de GradiumPhononTTSForConditionalGeneration surcharge 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, GradiumPhononTTSForConditionalGeneration

>>> model = GradiumPhononTTSForConditionalGeneration.from_pretrained("gradium/phonon-31m-en")

>>> processor = AutoProcessor.from_pretrained("gradium/phonon-31m-en")
>>> 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.

Update on GitHub

←GLM-ASR GraniteSpeech→