# Tokenizer audio Pocket TTS ## Aperçu Le tokenizer audio de [Pocket TTS](https://huggingface.co/kyutai/pocket-tts) : un codec doté de l’architecture de [Mimi](./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](https://huggingface.co/papers/2509.06926). 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](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel), [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel)). C’est le `audio_tokenizer` de [PocketTTSProcessor](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.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](https://huggingface.co/eustlb). Le code original est [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts). ## Utilisation ```python 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[[transformers.PocketTTSAudioTokenizerConfig]] #### transformers.PocketTTSAudioTokenizerConfig[[transformers.PocketTTSAudioTokenizerConfig]] ```python transformers.PocketTTSAudioTokenizerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L38) **Paramètres :** sampling_rate (`int`, *facultatif*, valeur 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*, valeur par défaut : 64) : Nombre de noyaux de convolution de la première couche `PocketTTSAudioTokenizerConv1d` de l'encodeur. num_residual_layers (`int`, *facultatif*, valeur par défaut 1) : Nombre de couches résiduelles. upsampling_ratios (`list[int]`, *facultatif*) : Ratios 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) : Amplitude de l'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*, valeur par défaut `"constant"`) : Mode de bourrage pour les convolutions. compress (`int`, *facultatif*, valeur par défaut : 2) : Dimensionnalité 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*, par défaut `False`) : Indique s'il faut utiliser une convolution comme connexion de saut des blocs résiduels SEANet ; les points de contrôle publiés n'en utilisent 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 vers le taux SEANet. num_hidden_layers (`int`, *facultatif*, valeur par défaut `2`) : Nombre de couches cachées dans le décodeur Transformer. intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations 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`) : C'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`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). 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 hidden_act (`str`, *facultatif*, par défaut `gelu_pytorch_tanh`) : 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*, valeur par défaut `8000`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. norm_eps (`float`, *facultatif*, valeur 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). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. use_streaming (`bool`, *facultatif*, par défaut `False`) : Indique si l'encodeur utilise le streaming par défaut : il renvoie alors le cache de padding 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*, valeur par défaut `250`) : Taille de la fenêtre de l'attention à fenêtre 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*, valeur 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*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de 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 sous-échantillonnage de la sortie SEANet vers les latents, et de la convolution transposée du décodeur qui les remonte. Une trame latente couvre `prod(upsampling_ratios) * latent_stride` échantillons audio (`frame_size`, 1920 pour les points de contrôle 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 en `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, en définissant 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](https://huggingface.co/eustlb/pocket-tts-audio-tokenizer) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel >>> # a full codec, and its decoder alone >>> model = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig()) >>> decoder_only = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig(encoder_config=None)) ``` ## PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]] #### transformers.PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]] ```python transformers.PocketTTSAudioTokenizerEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L214) Configuration de la moitié encodeur de PocketTTSAudioTokenizer (encodeur SEANet, transformeur encodeur et sous-échantillonnage). Il partage tous les champs avec [PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (voir sa documentation pour les arguments), il peut donc être chargé directement à partir d'un point de contrôle complet de PocketTTSAudioTokenizer. ## PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]] #### transformers.PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]] ```python transformers.PocketTTSAudioTokenizerDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, latent_stride: int = 16, latent_dim: int = 32) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L242) Configuration de la moitié décodeur de PocketTTSAudioTokenizer (suréchantillonnage, transformateur décodeur et décodeur SEANet). Elle partage tous les champs avec [PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (voir sa documentation pour les arguments), ce qui permet de la charger directement depuis un point de contrôle complet de PocketTTSAudioTokenizer. ## PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] #### transformers.PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]] ```python transformers.PocketTTSAudioTokenizerModel(config: PocketTTSAudioTokenizerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1179) **Paramètres :** config ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le tokenizer audio Pocket TTS : un codec de type 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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.PocketTTSAudioTokenizerModel.encode]] ```python encode(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1189) **Paramètres :** input_values (`torch.Tensor` de forme `(batch_size, audio_channels, num_samples)`) : Forme d'onde audio, telle que renvoyée par [EncodecFeatureExtractor](/docs/transformers/main/fr/model_doc/encodec#transformers.EncodecFeatureExtractor), qui l'arrondit par zéros à un multiple de `config.frame_size` échantillons, comme le fait 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`, *optional*) : Key-value cache of the encoder transformer, returned by the previous call when 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 à transmettre à l'appel suivant. Encode l’audio en latents continus de forme `(batch_size, num_frames, latent_dim)` : les latents de [PocketTTSAudioTokenizerEncoderModel.forward()](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel.forward), les frames en premier. #### decode[[transformers.PocketTTSAudioTokenizerModel.decode]] ```python decode(latents: Tensor, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1244) **Paramètres :** latents (`torch.Tensor` 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()](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel.forward). #### forward[[transformers.PocketTTSAudioTokenizerModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1272) **Paramètres :** input_values (`torch.Tensor` de forme `(batch_size, audio_channels, num_samples)`) : Forme d'onde audio, telle que renvoyée par [EncodecFeatureExtractor](/docs/transformers/main/fr/model_doc/encodec#transformers.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.Tensor)` Un `PocketTTSAudioTokenizerOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) et les entrées. La méthode forward du modèle [PocketTTSAudioTokenizerModel](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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.Tensor` 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.Tensor` de forme `(batch_size, audio_channels, num_samples)`) -- Forme d'onde audio reconstruite à partir des latents. - **hidden_states** (`tuple(torch.Tensor)`, *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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True`) -- Poids d'attention de chaque couche du transformeur encodeur. ## PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] #### transformers.PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]] ```python transformers.PocketTTSAudioTokenizerEncoderModel(config: PocketTTSAudioTokenizerEncoderConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L879) **Paramètres :** config ([PocketTTSAudioTokenizerEncoderConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.PocketTTSAudioTokenizerEncoderModel.forward]] ```python forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L940) **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é* ou 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 continu. 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 à transmettre à l'appel suivant. Encode la forme d'onde audio d'entrée en latents continus de forme `(batch_size, latent_dim, frames)`. -- **Retourne :** `PocketTTSAudioTokenizerEncoderModelOutput` ou `tuple(torch.Tensor)` Un `PocketTTSAudioTokenizerEncoderModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) et les entrées. La méthode forward du modèle [PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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.Tensor` 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.Tensor)`, *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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True`) -- Poids d'attention de chaque couche du transformeur encodeur. ## PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] #### transformers.PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]] ```python transformers.PocketTTSAudioTokenizerDecoderModel(config: PocketTTSAudioTokenizerDecoderConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1109) **Paramètres :** config ([PocketTTSAudioTokenizerDecoderConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.PocketTTSAudioTokenizerDecoderModel.forward]] ```python forward(latents: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1136) **Paramètres :** latents (`torch.Tensor` de forme `(batch_size, hidden_size, frames)`) : Latents continus à décoder, tels que calculés par [PocketTTSAudioTokenizerModel.decode()](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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é* ou 0 pour *masqué*. past_key_values (`Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) du transformeur décodeur, utilisés pour accélérer le décodage en flux. Décode les images données en une forme d'onde audio de sortie. Notez que la sortie peut être un peu plus grande que la -- input. Dans ce cas, les étapes supplémentaires à la fin peuvent être supprimées. -- **Retourne :** `PocketTTSAudioTokenizerDecoderOutput` ou `tuple(torch.Tensor)` Un `PocketTTSAudioTokenizerDecoderOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) et les entrées. La méthode forward du modèle [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/fr/model_doc/pocket_tts_audio_tokenizer#transformers.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.Tensor` 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. Il s'agit généralement des `past_key_values` renvoyé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 dont les états de clés passées n'ont pas été fournis à ce modèle). - **hidden_states** (`tuple(torch.Tensor)`, *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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True`) -- Poids d'attention de chaque couche du transformeur décodeur.