Hugging Face's logo

Transformers documentation

Tokenizer audio 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.

Tokenizer audio Pocket TTS

Aperçu

Le tokenizer audio de Pocket TTS : un codec doté de l’architecture de Mimi (convolutions SEANet et un petit transformer causal de chaque côté) dont le quantificateur vectoriel résiduel est remplacé par un goulot d’étranglement continu de 32 dimensions, le VAE-GAN de Continuous Audio Language Models. Il convertit l’audio 24 kHz en latents à 12,5 Hz et inversement. Son encodeur et son décodeur peuvent être chargés séparément (PocketTTSAudioTokenizerEncoderModel, PocketTTSAudioTokenizerDecoderModel). C’est le audio_tokenizer de PocketTTSProcessor, partagé par tous les points de contrôle Pocket TTS : le processeur encode les invites vocales à son aide et décode les latents générés.

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

Utilisation

from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

model = AutoModel.from_pretrained("eustlb/pocket-tts-audio-tokenizer", device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained("eustlb/pocket-tts-audio-tokenizer")

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=24000))
inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=24000, return_tensors="pt").to(model.device)

latents = model.encode(**inputs).latents
audio_values = model.decode(latents).audio_values

PocketTTSAudioTokenizerConfig

classe transformers.PocketTTSAudioTokenizerConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

Paramètres

  • sampling_rate (int, facultatif, par défaut 24000) — Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).
  • audio_channels (int, facultatif, valeur par défaut 1) — Nombre de canaux dans les données audio ; les points de contrôle publiés, ainsi que cette implémentation, sont en mono.
  • hidden_size (int, facultatif, par défaut 512) — Dimension des représentations cachées.
  • num_filters (int, facultatif, par défaut 64) — Nombre de noyaux de convolution de la première couche PocketTTSAudioTokenizerConv1d de l’encodeur.
  • num_residual_layers (int, facultatif, par défaut 1) — Nombre de couches résiduelles.
  • upsampling_ratios (list[int], facultatif) — Rapports de taille de noyau et de pas des convolutions transposées du décodeur ; l’encodeur les utilise dans l’ordre inverse. Si non spécifié, la valeur par défaut est [6, 5, 4].
  • kernel_size (int, facultatif, par défaut 7) — La taille du noyau de convolution.
  • last_kernel_size (int, facultatif, valeur par défaut 3) — Taille du noyau pour la dernière couche de convolution.
  • residual_kernel_size (int, facultatif, valeur par défaut 3) — Taille du noyau pour les couches résiduelles.
  • dilation_growth_rate (int, facultatif, valeur par défaut 2) — Facteur d'augmentation de la dilatation à chaque couche.
  • use_causal_conv (bool, facultatif, par défaut True) — Indique s'il faut utiliser une convolution entièrement causale.
  • pad_mode (str, facultatif, par défaut "constant") — Mode de bourrage pour les convolutions.
  • compress (int, facultatif, par défaut 2) — Dimension réduite dans les branches résiduelles.
  • trim_right_ratio (float, facultatif, valeur par défaut 1.0) — Ratio de rognage à droite de la convolution transposée dans la configuration use_causal_conv = True. S'il est égal à 1.0, cela signifie que tout le rognage est effectué à droite.
  • use_conv_shortcut (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser une convolution comme connexion de contournement des blocs résiduels SEANet ; les points de contrôle publiés ne le font pas.
  • upsample_groups (int, facultatif, valeur par défaut 512) — Nombre de groupes de la convolution transposée qui effectue le suréchantillonnage des latents jusqu'au taux SEANet.
  • num_hidden_layers (int, facultatif, par défaut 2) — Nombre de couches cachées dans le décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 2048) — Dimension des représentations du MLP.
  • num_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_key_value_heads (int, facultatif, valeur par défaut 8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si num_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), si num_key_value_heads=1 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention 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 en effectuant un 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 sera 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
  • 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.
  • max_position_embeddings (int, facultatif, par défaut 8000) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • 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.
  • norm_eps (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • use_cache (bool, facultatif, valeur par défaut False) — 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.
  • use_streaming (bool, facultatif, par défaut False) — Indique si l'encodeur diffuse par défaut : il renvoie alors le cache de bourrage et le cache clé-valeur à transmettre à l'appel suivant.
  • 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.
  • sliding_window (int, facultatif, par défaut 250) — Taille de la fenêtre d'attention glissante. Si None, aucune fenêtre glissante n'est appliquée.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • layer_scale_initial_scale (float, facultatif, par défaut 0.01) — Échelle à utiliser dans les couches d'auto-attention. 0.1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche.
  • 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.
  • latent_stride (int, facultatif, valeur par défaut 16) — Nombre de trames SEANet par trame latente : le pas de la convolution de l’encodeur qui effectue le downsampling de la sortie SEANet vers les latents, et de la convolution transposée du décodeur qui effectue l’upsampling inverse. Une trame latente couvre prod(upsampling_ratios) * latent_stride échantillons audio (frame_size, 1920 pour les checkpoints publiés).
  • latent_dim (int, facultatif, valeur par défaut 32) — Dimension des latents continus. Le quantificateur vectoriel résiduel de Mimi est remplacé par ce goulot d’étranglement : la convolution de sous-échantillonnage de l’encodeur produit latent_dim canaux, et le décodeur les projette à nouveau vers hidden_size avant le sur-échantillonnage.

Ceci est la classe de configuration destinée à stocker la configuration d'un PocketTTSAudioTokenizerModel. Elle est utilisée pour instancier un modèle Pocket Tts Audio Tokenizer 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-audio-tokenizer

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.

Exemple :

>>> from transformers import PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel

>>> # a full codec, and its decoder alone
>>> model = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig())
>>> decoder_only = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig(encoder_config=None))

PocketTTSAudioTokenizerEncoderConfig

classe transformers.PocketTTSAudioTokenizerEncoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

Configuration de la moitié encodeur de PocketTTSAudioTokenizer (encodeur SEANet, transformeur encodeur et sous-échantillonnage). Il partage tous les champs avec PocketTTSAudioTokenizerConfig (voir sa documentation pour les arguments), il peut donc être chargé directement depuis un point de contrôle complet de PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerDecoderConfig

classe transformers.PocketTTSAudioTokenizerDecoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0use_conv_shortcut: bool = Falseupsample_groups: int = 512num_hidden_layers: int = 2intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falselatent_stride: int = 16latent_dim: int = 32 )

Configuration de la moitié décodeur de PocketTTSAudioTokenizer (remontée en fréquence, transformeur décodeur et décodeur SEANet). Elle partage tous les champs avec PocketTTSAudioTokenizerConfig (voir sa documentation pour les arguments), elle peut donc être chargée directement depuis un point de contrôle complet de PocketTTSAudioTokenizer.

PocketTTSAudioTokenizerModel

classe transformers.PocketTTSAudioTokenizerModel

< >

( config: PocketTTSAudioTokenizerConfig )

Paramètres

  • config (PocketTTSAudioTokenizerConfig) — 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 tokenizer audio Pocket TTS : un codec d'architecture Mimi doté d'un latent continu de 32 dimensions à 12,5 Hz (le VAE-GAN des Continuous Audio Language Models), qui convertit l'audio 24 kHz en latents et inversement.

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.

encode

< >

( input_values: FloatTensorpadding_mask: typing.Optional[torch.Tensor] = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Paramètres

  • input_values (torch.FloatTensor de forme (batch_size, audio_channels, num_samples)) — Forme d’onde audio, telle que renvoyée par EncodecFeatureExtractor, qui l’arrondit par zéros à un multiple de config.frame_size échantillons, comme l’original.
  • padding_mask (torch.Tensor de forme (batch_size, num_samples), facultatif) — Masque des échantillons audio (1) par opposition au bourrage (0), à partir duquel latents_mask est calculé.
  • encoder_past_key_values (Cache, facultatif) — Mémoire cache des clés-valeurs du transformeur encodeur, renvoyée par l’appel précédent lors du streaming.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, facultatif) — Cache de bourrage des convolutions causales de l’encodeur, renvoyé par l’appel précédent lors du streaming.
  • use_streaming (bool, facultatif) — Indique s'il faut encoder en mode streaming, en renvoyant les caches à passer à l'appel suivant.

Encode l’audio en latents continus de forme (batch_size, num_frames, latent_dim) : les latents de PocketTTSAudioTokenizerEncoderModel.forward(), les frames en premier.

décoder

< >

( latents: FloatTensordecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Paramètres

  • latents (torch.FloatTensor de forme (batch_size, num_frames, latent_dim)) — Latents continus à décoder, un frame par config.frame_size échantillons audio.
  • decoder_past_key_values (Cache, optional) — Key-value cache of the decoder transformer, returned by the previous call when decoding in chunks.

Décode les latents continus en audio : les latents sont projetés vers hidden_size, puis décodés par PocketTTSAudioTokenizerDecoderModel.forward().

forward

< >

( input_values: FloatTensorpadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerOutput or tuple(torch.FloatTensor)

Paramètres

  • input_values (torch.FloatTensor de forme (batch_size, audio_channels, num_samples)) — Forme d’onde audio, telle que renvoyée par EncodecFeatureExtractor.
  • padding_mask (torch.Tensor de forme (batch_size, num_samples), facultatif) — Masque des échantillons audio (1) par opposition au bourrage (0).

Retourne

PocketTTSAudioTokenizerOutput ou tuple(torch.FloatTensor)

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

La méthode forward du modèle PocketTTSAudioTokenizerModel 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.

  • latents (torch.FloatTensor de forme (batch_size, num_frames, latent_dim)) — Latents continus de l'audio.
  • latents_mask (torch.LongTensor de forme (batch_size, num_frames), facultatif) — Masque des trames latentes calculées à partir d'échantillons audio (1) plutôt que de bourrage (0).
  • audio_values (torch.FloatTensor de forme (batch_size, audio_channels, num_samples)) — Forme d'onde audio reconstruite à partir des latents.
  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True) — États cachés du transformeur encodeur à la sortie de chaque couche ainsi que son entrée.
  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de chaque couche du transformeur encodeur.

PocketTTSAudioTokenizerEncoderModel

classe transformers.PocketTTSAudioTokenizerEncoderModel

< >

( config: PocketTTSAudioTokenizerEncoderConfig )

Paramètres

  • config (PocketTTSAudioTokenizerEncoderConfig) — 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.

La moitié encodeur de PocketTTSAudioTokenizer : encodeur SEANet, transformeur encodeur et sous-échantillonnage, de l'audio aux latents continus.

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_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerEncoderModelOutput or tuple(torch.FloatTensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, channels, sequence_length)) — Valeurs flottantes de la forme d'onde audio d'entrée.
  • padding_mask (torch.Tensor de forme (batch_size, channels, sequence_length), facultatif) — Indique quelles entrées doivent être ignorées en raison du bourrage, où les éléments sont soit 1 pour non masqué soit 0 pour masqué.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur encodeur, utilisés pour accélérer l'encodage en flux.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, facultatif) — Cache de bourrage des convolutions causales, utilisé pour l’encodage en flux.
  • use_streaming (bool, facultatif) — Indique s'il faut encoder en mode streaming, en renvoyant les caches à passer à l'appel suivant.
  • Encodes la forme d'onde audio d'entrée en latents continus de forme (batch_size, latent_dim, frames). —

Retourne

PocketTTSAudioTokenizerEncoderModelOutput ou tuple(torch.FloatTensor)

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

La méthode forward du modèle PocketTTSAudioTokenizerEncoderModel 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.

  • latents (torch.FloatTensor de forme (batch_size, latent_dim, frames)) — Latents continus de l'audio, une trame par config.frame_size échantillons audio.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur encodeur, renvoyés lors du streaming.
  • padding_cache (PocketTTSAudioTokenizerConv1dPaddingCache, facultatif) — Cache de bourrage pour les convolutions causales de PocketTTSAudioTokenizerConv1d afin de prendre en charge le streaming via le bourrage du cache.
  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True) — États cachés du transformeur encodeur à la sortie de chaque couche ainsi que son entrée.
  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de chaque couche du transformeur encodeur.

PocketTTSAudioTokenizerDecoderModel

classe transformers.PocketTTSAudioTokenizerDecoderModel

< >

( config: PocketTTSAudioTokenizerDecoderConfig )

Paramètres

  • config (PocketTTSAudioTokenizerDecoderConfig) — 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.

La moitié décodeur de PocketTTSAudioTokenizer : suréchantillonnage, transformeur décodeur et décodeur SEANet, des latents continus à l'audio.

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

< >

( latents: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PocketTTSAudioTokenizerDecoderOutput or tuple(torch.FloatTensor)

Paramètres

  • latents (torch.FloatTensor de forme (batch_size, hidden_size, frames)) — Latents continus à décoder, tels que calculés par PocketTTSAudioTokenizerModel.decode().
  • padding_mask (torch.Tensor de forme (batch_size, channels, sequence_length), facultatif) — Indique quelles entrées doivent être ignorées en raison du bourrage, où les éléments sont soit 1 pour non masqué soit 0 pour masqué.
  • past_key_values (Cache, facultatif) — États cachés précalculés (clés et valeurs des blocs d'auto-attention) du transformeur décodeur, utilisés pour accélérer le décodage en flux.
  • Decodes les images données en une forme d'onde audio de sortie. Notez que la sortie peut être légèrement plus grande que la —
  • input. Dans ce cas, les étapes supplémentaires à la fin peuvent être supprimées. —

Retourne

PocketTTSAudioTokenizerDecoderOutput ou tuple(torch.FloatTensor)

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

La méthode forward du modèle PocketTTSAudioTokenizerDecoderModel 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.

  • audio_values (torch.FloatTensor de forme (batch_size, audio_channels, num_samples), facultatif) — Valeurs audio décodées, obtenues à l’aide de la partie décodeur de PocketTTSAudioTokenizer.

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

    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 peut éventuellement n’entrer que les derniers audio_values ou `audio_codes (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle).

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True) — États cachés du transformeur décodeur à la sortie de chaque couche ainsi que son entrée.

  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de chaque couche du transformeur décodeur.

Update on GitHub

←Pocket TTS Pop2Piano→