Hugging Face's logo

Transformers documentation

SpeechT5

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é publié dans les papiers HF le 2021-10-14 et contribué à Hugging Face Transformers le 2023-02-03.

SpeechT5

Aperçu

Le modèle SpeechT5 a été proposé dans SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing par Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.

L'abstract de l'article est le suivant :

Inspiré par le succès de T5 (Text-To-Text Transfer Transformer) dans les modèles de traitement du langage naturel pré-entraînés, nous proposons un cadre unimodal SpeechT5 qui explore l'entraînement préliminaire encodeur-décodeur pour l'apprentissage auto-supervisé de représentations vocales/textuelles. Le cadre SpeechT5 se compose d'un réseau encodeur-décodeur partagé et de six réseaux pré/post spécifiques aux modalités (voix/texte). Après le prétraitement de la voix/du texte d'entrée via les réseaux pré, le réseau encodeur-décodeur partagé modélise la transformation séquence-à-séquence, puis les réseaux post génèrent la sortie dans la modalité voix/texte sur la base de la sortie du décodeur. En exploitant de grandes quantités de données vocales et textuelles non étiquetées, nous pré-entraînons SpeechT5 pour apprendre une représentation unimodale, dans l'espoir d'améliorer la capacité de modélisation pour la voix et le texte. Pour aligner les informations textuelles et vocales dans cet espace sémantique unifié, nous proposons une approche de quantification vectorielle intermodale qui mélange aléatoirement les états voix/texte avec des unités latentes servant d'interface entre l'encodeur et le décodeur. Des évaluations exhaustives démontrent la supériorité du cadre SpeechT5 proposé sur une grande variété de tâches de traitement du langage parlé, y compris la reconnaissance automatique de la parole, la synthèse vocale, la traduction vocale, la conversion de voix, l'amélioration de la parole et l'identification de locuteur.

Ce modèle a été contribué par Matthijs. Le code d'origine peut être trouvé ici.

Définissez use_kernels=True dans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez Chargement des noyaux pour en savoir plus.

SpeechT5Config

classe transformers.SpeechT5Config

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 81hidden_size: int = 768encoder_layers: int = 12encoder_attention_heads: int = 12encoder_ffn_dim: int = 3072encoder_layerdrop: float | int = 0.1decoder_layers: int = 6decoder_ffn_dim: int = 3072decoder_attention_heads: int = 12decoder_layerdrop: float | int = 0.1hidden_act: str = 'gelu'positional_dropout: float | int = 0.1hidden_dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05scale_embedding: bool = Falsefeat_extract_norm: str = 'group'feat_proj_dropout: float | int = 0.0feat_extract_activation: str = 'gelu'conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_bias: bool = Falsenum_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16apply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2decoder_start_token_id: int | None = 2num_mel_bins: int = 80speech_decoder_prenet_layers: int = 2speech_decoder_prenet_units: int = 256speech_decoder_prenet_dropout: float | int = 0.5speaker_embedding_dim: int = 512speech_decoder_postnet_layers: int = 5speech_decoder_postnet_units: int = 256speech_decoder_postnet_kernel: int = 5speech_decoder_postnet_dropout: float | int = 0.5reduction_factor: int = 2max_speech_positions: int = 4000max_text_positions: int = 450encoder_max_relative_position: int = 160use_guided_attention_loss: bool = Trueguided_attention_loss_num_heads: int = 2guided_attention_loss_sigma: float = 0.4guided_attention_loss_scale: float = 10.0use_cache: bool = Truetie_word_embeddings: bool = True )

Paramètres

  • is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
  • vocab_size (int, facultatif, par défaut 81) — 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.
  • encoder_layers (int, facultatif, valeur par défaut 12) — Nombre de couches cachées dans l’encodeur Transformer. Utilise la même valeur que num_layers si non défini.
  • encoder_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.
  • encoder_ffn_dim (int, facultatif, valeur par défaut 3072) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur.
  • encoder_layerdrop (Union[float, int], facultatif, valeur par défaut 0.1) — Probabilité de LayerDrop pour l'encodeur. Voir l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
  • decoder_layers (int, facultatif, valeur par défaut 6) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que num_layers si non défini.
  • decoder_ffn_dim (int, facultatif, valeur par défaut 3072) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.
  • decoder_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • decoder_layerdrop (Union[float, int], facultatif, valeur par défaut 0.1) — Probabilité de LayerDrop pour le décodeur. Consultez l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
  • 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.
  • positional_dropout (float, facultatif, valeur par défaut 0.1) — Probabilité de dropout pour les couches d'encodage de position du texte.
  • hidden_dropout (Union[float, int], facultatif, valeur par défaut 0.1) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • activation_dropout (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
  • 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.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • scale_embedding (bool, facultatif, par défaut False) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).
  • feat_extract_norm (str, facultatif, valeur par défaut "group") — La normalisation à appliquer aux couches de convolution 1D du pré-réseau de l'encodeur audio. Soit "group" pour une normalisation par groupe appliquée uniquement à la première couche de convolution 1D, soit "layer" pour une normalisation par couche appliquée à toutes les couches de convolution 1D.
  • feat_proj_dropout (float, facultatif, valeur par défaut 0.0) — Probabilité de dropout appliquée à la sortie du pré-réseau de l'encodeur vocal.
  • feat_extract_activation (str, optional, defaults to “gelu”) -- The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, “gelu”, “relu”, “selu”and“gelu_new”` are supported.
  • conv_dim (tuple[int] ou list[int], facultatif, par défaut (512, 512, 512, 512, 512, 512, 512)) — Un tuple d'entiers définissant le nombre de canaux d'entrée et de sortie de chaque couche de convolution 1D du pré-réseau de l'encodeur vocal. La longueur de conv_dim définit le nombre de couches de convolution 1D.
  • conv_stride (tuple[int] ou list[int], facultatif, valeur par défaut (5, 2, 2, 2, 2, 2, 2)) — Un tuple d'entiers définissant le pas de chaque couche convolutive 1D du pré-réseau de l'encodeur audio. La longueur de conv_stride définit le nombre de couches convolutives et doit correspondre à la longueur de conv_dim.
  • conv_kernel (tuple[int] ou list[int], facultatif, par défaut (10, 3, 3, 3, 3, 3, 3)) — Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du pré-réseau de l'encodeur audio. La longueur de conv_kernel définit le nombre de couches convolutives et doit correspondre à la longueur de conv_dim.
  • conv_bias (bool, facultatif, par défaut False) — Indique si les couches de convolution 1D ont un biais.
  • num_conv_pos_embeddings (int, facultatif, valeur par défaut 128) — Nombre d'embeddings positionnels convolutifs. Définit la taille du noyau de la couche d'embeddings positionnels convolutifs 1D.
  • num_conv_pos_embedding_groups (int, facultatif, valeur par défaut 16) — Nombre de groupes de la couche d'encodages positionnels convolutifs 1D.
  • apply_spec_augment (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer l'augmentation de données SpecAugment aux sorties du pré-réseau de l'encodeur de parole. Pour référence, voir SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition.
  • mask_time_prob (float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates ”mask_time_problen(time_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_time_prob should be `prob_vector_startmask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_time_length (int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe temporel.
  • mask_time_min_masks (int, facultatif, valeur par défaut 2), — Le nombre minimal de masques de longueur mask_feature_length générés le long de l’axe temporel, à chaque étape temporelle, indépendamment de mask_feature_prob. Ne concerne que le cas où ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”
  • mask_feature_prob (float, optional, defaults to 0.0) — Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates ”mask_feature_problen(feature_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_feature_prob should be `prob_vector_startmask_feature_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_feature_prob (Union[float, int], facultatif, valeur par défaut 0.0) — Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe des caractéristiques qui seront masqués. La procédure de masquage génère mask_feature_prob*len(feature_axis)/mask_time_length masques indépendants sur l'axe. Si l'on raisonne à partir de la probabilité que chaque vecteur de caractéristiques soit choisi comme début de la portée de vecteurs à masquer, mask_feature_prob doit être prob_vector_start*mask_feature_length. Notez que les chevauchements peuvent diminuer le pourcentage réel de vecteurs masqués. Cela n'est pertinent que si apply_spec_augment est True.
  • mask_feature_length (int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe des caractéristiques.
  • mask_feature_min_masks (int, facultatif, valeur par défaut 0), — Le nombre minimal de masques de longueur mask_feature_length générés le long de l’axe des caractéristiques, à chaque étape, indépendamment de mask_feature_prob. Ne concerne que le cas où ”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”
  • num_mel_bins (int, facultatif, valeur par défaut 80) — Nombre de caractéristiques mel utilisées par les caractéristiques d'entrée. Utilisé par le pré-réseau du décodeur vocal. Doit correspondre à la valeur utilisée dans la classe SpeechT5Processor.
  • pad_token_id (int, facultatif, par défaut 1) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • decoder_start_token_id (int, facultatif, valeur par défaut 2) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent de bos, l’identifiant de ce jeton.
  • num_mel_bins (int, facultatif, valeur par défaut 80) — Nombre de caractéristiques mel utilisées par tranche d’entrée. Doit correspondre à la valeur utilisée dans la classe AutoFeatureExtractor.
  • speech_decoder_prenet_layers (int, facultatif, valeur par défaut : 2) — Nombre de couches dans le pré-réseau du décodeur vocal.
  • speech_decoder_prenet_units (int, facultatif, valeur par défaut : 256) — Dimension des couches du pré-réseau du décodeur vocal.
  • speech_decoder_prenet_dropout (float, facultatif, valeur par défaut 0,5) — Probabilité de dropout pour les couches du pré-réseau du décodeur vocal.
  • speaker_embedding_dim (int, facultatif, par défaut 512) — Dimension des vecteurs d'incorporation XVector.
  • speech_decoder_postnet_layers (int, facultatif, valeur par défaut : 5) — Nombre de couches dans le post-net du décodeur vocal.
  • speech_decoder_postnet_units (int, facultatif, valeur par défaut : 256) — Dimension des couches du post-net du décodeur vocal.
  • speech_decoder_postnet_kernel (int, facultatif, valeur par défaut : 5) — Nombre de canaux de filtres convolutifs dans le post-net du décodeur vocal.
  • speech_decoder_postnet_dropout (float, facultatif, valeur par défaut 0,5) — Probabilité de dropout pour les couches post-net du décodeur de parole.
  • reduction_factor (int, facultatif, valeur par défaut : 2) — Facteur de réduction de la longueur du spectrogramme pour les entrées du décodeur vocal.
  • max_speech_positions (int, facultatif, par défaut 4000) — La longueur de séquence maximale des caractéristiques vocales avec laquelle ce modèle pourrait être utilisé.
  • max_text_positions (int, facultatif, valeur par défaut : 450) — La longueur de séquence maximale des caractéristiques de texte avec laquelle ce modèle pourrait être utilisé.
  • encoder_max_relative_position (int, facultatif, valeur par défaut : 160) — Distance maximale pour l'intégration de position relative dans l'encodeur.
  • use_guided_attention_loss (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer la perte d'attention guidée lors de l'entraînement du modèle TTS.
  • guided_attention_loss_num_heads (int, facultatif, valeur par défaut : 2) — Nombre de têtes d'attention auxquelles la perte d'attention guidée sera appliquée. Utilisez -1 pour appliquer cette perte à toutes les têtes d'attention.
  • guided_attention_loss_sigma (float, facultatif, valeur par défaut 0.4) — Écart type pour la perte d'attention guidée.
  • guided_attention_loss_scale (float, facultatif, valeur par défaut 10.0) — Coefficient de mise à l'échelle de la perte d'attention guidée (également connu sous le nom de lambda).
  • 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.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un SpeechT5Model. Elle est utilisée pour instancier un modèle Speecht5 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 produit une configuration similaire à celle de microsoft/speecht5_asr

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 SpeechT5Model, SpeechT5Config

>>> # Initializing a "microsoft/speecht5_asr" style configuration
>>> configuration = SpeechT5Config()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_asr" style configuration
>>> model = SpeechT5Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

SpeechT5HifiGanConfig

classe transformers.SpeechT5HifiGanConfig

< >

( 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 = Nonemodel_in_dim: int = 80sampling_rate: int = 16000upsample_initial_channel: int = 512upsample_rates: list[int] | tuple[int, ...] = (4, 4, 4, 4)upsample_kernel_sizes: list[int] | tuple[int, ...] = (8, 8, 8, 8)resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))initializer_range: float = 0.01leaky_relu_slope: float = 0.1normalize_before: bool = True )

Paramètres

  • model_in_dim (int, facultatif, valeur par défaut 80) — Le nombre de bandes de fréquence dans le spectrogramme log-mél d'entrée.
  • sampling_rate (int, facultatif, par défaut 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • upsample_initial_channel (int, facultatif, valeur par défaut 512) — Le nombre de canaux d'entrée du réseau de suréchantillonnage.
  • upsample_rates (tuple[int] ou list[int], facultatif, par défaut [4, 4, 4, 4]) — Un tuple d'entiers définissant le pas de chaque couche de convolution 1D du réseau de remontée en résolution. La longueur de upsample_rates définit le nombre de couches de convolution et doit correspondre à la longueur de upsample_kernel_sizes.
  • upsample_kernel_sizes (tuple[int] ou list[int], facultatif, par défaut [8, 8, 8, 8]) — Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du réseau de remontée en résolution. La longueur de upsample_kernel_sizes définit le nombre de couches convolutives et doit correspondre à la longueur de upsample_rates.
  • resblock_kernel_sizes (tuple[int] ou list[int], facultatif, par défaut [3, 7, 11]) — Un tuple d'entiers définissant les tailles de noyau des couches de convolution 1D dans le module de fusion multi-champ réceptif (MRF).
  • resblock_dilation_sizes (tuple[tuple[int]] ou list[list[int]], facultatif, par défaut [[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — Un tuple imbriqué d'entiers définissant les taux de dilatation des couches de convolution 1D dilatées du module de fusion multi-champ réceptif (MRF).
  • initializer_range (float, facultatif, par défaut 0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • leaky_relu_slope (float, facultatif, valeur par défaut 0.1) — L'angle de la pente négative utilisé par la fonction d'activation leaky ReLU.
  • normalize_before (bool, facultatif, par défaut True) — Indique s'il faut normaliser le spectrogramme avant la vocodisation en utilisant la moyenne et la variance apprises par le vocodeur.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un SpeechT5Model. Elle est utilisée pour instancier un modèle Speecht5 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 produit une configuration similaire à celle de microsoft/speecht5_asr

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 SpeechT5HifiGan, SpeechT5HifiGanConfig

>>> # Initializing a "microsoft/speecht5_hifigan" style configuration
>>> configuration = SpeechT5HifiGanConfig()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_hifigan" style configuration
>>> model = SpeechT5HifiGan(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

SpeechT5Tokenizer

classe transformers.SpeechT5Tokenizer

< >

( vocab_filebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'normalize = Falsesp_model_kwargs: dict[str, typing.Any] | None = None**kwargs )

Paramètres

  • vocab_file (str) — fichier SentencePiece (généralement avec l’extension .spm) qui contient le vocabulaire nécessaire pour instancier un tokeniseur.
  • bos_token (str, facultatif, par défaut "<s>") — Le jeton de début de séquence.
  • eos_token (str, facultatif, par défaut "</s>") — Le jeton de fin de séquence.
  • unk_token (str, facultatif, par défaut "<unk>") — Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.
  • pad_token (str, facultatif, par défaut "<pad>") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes.
  • normalize (bool, facultatif, valeur par défaut False) — Indique s'il faut convertir les quantités numériques du texte en leurs équivalents anglais écrits en toutes lettres.
  • sp_model_kwargs (dict, facultatif) — Sera transmis à la méthode SentencePieceProcessor.__init__() . Le wrapper Python de SentencePiece peut être utilisé, entre autres, pour définir :

    • enable_sampling : Active la régularisation des sous-mots.

    • nbest_size : Paramètres d'échantillonnage pour les unigrammes. Invalide pour BPE-Dropout.

      • nbest_size = {0,1} : Aucun échantillonnage n'est effectué.
      • nbest_size > 1 : échantillonne parmi les résultats de nbest_size.
      • nbest_size < 0 : suppose que nbest_size est infini et échantillonne à partir de toutes les hypothèses (lattice) en utilisant l'algorithme de filtrage avant et d'échantillonnage arrière.

    • alpha : Paramètre de lissage pour l'échantillonnage des unigrammes et probabilité de suppression pour les opérations de fusion dans le cas du BPE-dropout.

  • sp_model (SentencePieceProcessor) — Le processeur SentencePiece utilisé pour chaque conversion (chaîne, jetons et identifiants).

Construit un tokenizer SpeechT5. Basé sur SentencePiece.

Ce tokenizer hérite de PreTrainedTokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__call__

< >

( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding

Paramètres

  • text (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_pair (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_pair_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • tokenizer_kwargs (dict[str, Any], facultatif) — Kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité.
  • add_special_tokens (bool, facultatif, par défaut True) — Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacente PretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons bos ou eos.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Cela tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • 'only_first' : Tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.
    • 'only_second' : Tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.
    • False ou 'do_not_truncate' (par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé.

  • stride (int, facultatif, valeur par défaut 0) — Si défini à un nombre avec max_length, les jetons en dépassement renvoyés lorsque return_overflowing_tokens=True contiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
  • is_split_into_words (bool, facultatif, par défaut False) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini à True, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et la tokenise. Cela est utile pour la NER ou la classification de tokens.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation de padding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).
  • padding_side (str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • return_token_type_ids (bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton sont renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut return_outputs .

    Qu'est-ce que les identifiants de type de jeton ?

  • return_attention_mask (bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut return_outputs .

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

  • return_overflowing_tokens (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec truncation_strategy = longest_first ou True, une erreur est levée au lieu de retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.
  • return_offsets_mapping (bool, facultatif, par défaut False) — Indique s'il faut renvoyer (char_start, char_end) pour chaque jeton.

    Cela n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève NotImplementedError.

  • return_length (bool, facultatif, par défaut False) — Indique s'il faut retourner les longueurs des entrées encodées.
  • verbose (bool, facultatif, par défaut True) — Indique s'il faut afficher plus d'informations et d'avertissements.
  • **kwargs — transmis à la méthode self.tokenize()

Retourne

BatchEncoding

Un BatchEncoding avec les champs suivants :

  • input_ids — Liste des identifiants de jetons à fournir à un modèle.

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

  • token_type_ids — Liste des identifiants de type de jeton à fournir à un modèle (lorsque return_token_type_ids=True ou si “token_type_ids” est présent dans self.model_input_names).

    Qu'est-ce que les identifiants de type de jeton ?

  • attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque return_attention_mask=True ou si “attention_mask” est présent dans self.model_input_names).

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

  • overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).

  • num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).

  • special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque add_special_tokens=True et return_special_tokens_mask=True).

  • length — La longueur des entrées (lorsque return_length=True)

Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None ) → tuple(str)

Paramètres

  • save_directory (str) — Le répertoire dans lequel enregistrer le vocabulaire.
  • filename_prefix (str, facultatif) — Préfixe facultatif à ajouter au nom des fichiers enregistrés.

Retourne

tuple(str)

Chemin des fichiers enregistrés.

Enregistrez le vocabulaire sentencepiece (copie du fichier d'origine) dans un répertoire.

décoder

< >

( token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = False**kwargs ) → Union[str, list[str]]

Paramètres

  • token_ids (Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Une séquence unique ou un lot (liste de séquences) d’identifiants d’entrée tokenisés. Peut être obtenu à l’aide de la méthode __call__.
  • skip_special_tokens (bool, facultatif, valeur par défaut False) — Indique s'il faut supprimer les jetons spéciaux lors du décodage.
  • kwargs (arguments supplémentaires par mot-clé, facultatif) — Sera transmis à la méthode de décodage spécifique du modèle sous-jacent.

Retourne

Union[str, list[str]]

La chaîne décodée pour une séquence unique, ou une liste de chaînes décodées pour un lot de séquences.

Convertit une séquence d'identifiants en chaîne de caractères, ou une liste de séquences en liste de chaînes de caractères, en utilisant le tokenizer et le vocabulaire, avec des options pour supprimer les jetons spéciaux et nettoyer les espaces de tokenization.

Similaire à l'exécution de self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids)).

batch_decode

< >

( sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]

Paramètres

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Liste des identifiants d’entrée tokenisés. Peut être obtenue à l’aide de la méthode __call__.
  • skip_special_tokens (bool, facultatif, valeur par défaut False) — Indique s'il faut supprimer les jetons spéciaux lors du décodage.
  • clean_up_tokenization_spaces (bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. Si None, la valeur par défaut est self.clean_up_tokenization_spaces.
  • kwargs (arguments supplémentaires par mot-clé, facultatif) — Sera transmis à la méthode de décodage spécifique du modèle sous-jacent.

Retourne

list[str]

La liste des phrases décodées.

Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.

Cette méthode est fournie pour la compatibilité ascendante. La méthode decode gère désormais nativement les entrées par lots, vous pouvez donc utiliser directement decode au lieu de batch_decode.

SpeechT5FeatureExtractor

classe transformers.SpeechT5FeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 16000padding_value: float = 0.0do_normalize: bool = Falsenum_mel_bins: int = 80hop_length: int = 16win_length: int = 64win_function: str = 'hann_window'fmin: float = 80fmax: float = 7600mel_floor: float = 1e-10return_attention_mask: bool = True**kwargs )

Paramètres

  • feature_size (int, facultatif, valeur par défaut 1) — La dimension des caractéristiques des fonctionnalités extraites.
  • sampling_rate (int, facultatif, valeur par défaut 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • padding_value (float, facultatif, valeur par défaut 0.0) — La valeur utilisée pour remplir les valeurs de bourrage.
  • do_normalize (bool, facultatif, valeur par défaut False) — Indique s'il faut normaliser l'entrée en moyenne nulle et variance unitaire. La normalisation peut contribuer à améliorer significativement les performances de certains modèles.
  • num_mel_bins (int, facultatif, valeur par défaut : 80) — Le nombre de bandes de fréquences mel dans les caractéristiques du spectrogramme extrait.
  • hop_length (int, facultatif, valeur par défaut : 16) — Nombre de ms entre les fenêtres. Également appelé « shift » dans de nombreux articles.
  • win_length (int, facultatif, par défaut 64) — Nombre de ms par fenêtre.
  • win_function (str, facultatif, par défaut "hann_window") — Nom de la fonction de fenêtre utilisée pour le fenêtrage, doit être accessible via torch.{win_function}
  • fmin (float, facultatif, valeur par défaut 80) — Fréquence mélinique minimale en Hz.
  • fmax (float, facultatif, valeur par défaut 7600) — Fréquence mél maximale en Hz.
  • mel_floor (float, facultatif, valeur par défaut 1e-10) — Valeur minimale des banques de fréquences mel.
  • return_attention_mask (bool, facultatif, par défaut True) — Indique si call() doit retourner attention_mask.

Construit un extracteur de fonctionnalités SpeechT5.

Cette classe peut pré-traiter un signal audio brut en le normalisant (facultativement) pour obtenir une moyenne nulle et une variance unitaire, afin d’être utilisé par le pré-réseau de l’encodeur audio de SpeechT5.

Cette classe peut également extraire des caractéristiques de banque de filtres log-mel à partir de la parole brute, pour être utilisées par le prénet du décodeur de parole SpeechT5.

Cet extracteur de fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = Noneaudio_target: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsemax_length: int | None = Nonetruncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None**kwargs )

Paramètres

  • audio (np.ndarray, list[float], list[np.ndarray], list[list[float]], facultatif) — La séquence ou le lot de séquences à traiter. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Cela produit des caractéristiques de forme d'onde. L'audio doit être en canal mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.
  • audio_target (np.ndarray, list[float], list[np.ndarray], list[list[float]], facultatif) — La séquence ou le lot de séquences à traiter en tant que cibles. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Cela produit des caractéristiques de spectrogramme log-mel.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi les options suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • max_length (int, facultatif) — Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).
  • truncation (bool) — Active la troncature pour couper les séquences d’entrée plus longues que max_length à max_length.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie.

    Ceci est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta), ou sur les TPU qui bénéficient d'avoir des longueurs de séquence qui sont un multiple de 128.

  • return_attention_mask (bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du feature_extractor spécifique.

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

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • sampling_rate (int, facultatif) — La fréquence d'échantillonnage à laquelle l'entrée audio ou audio_target a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l'appel forward afin d'éviter les erreurs silencieuses.

Méthode principale pour vectoriser et préparer une ou plusieurs séquences pour le modèle.

Transmettez une valeur pour audio afin d'extraire les caractéristiques de la forme d'onde. Transmettez une valeur pour audio_target afin d'extraire les caractéristiques du spectrogramme log-mel.

SpeechT5Processor

classe transformers.SpeechT5Processor

< >

( feature_extractortokenizer )

Paramètres

  • feature_extractor (SpeechT5FeatureExtractor) — L’extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (SpeechT5Tokenizer) — Le tokenizer est une entrée obligatoire.

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

SpeechT5Processor propose toutes les fonctionnalités de SpeechT5FeatureExtractor et de SpeechT5Tokenizer. Consultez ~SpeechT5FeatureExtractor et ~SpeechT5Tokenizer pour plus d’informations.

__call__

< >

( *args**kwargs )

Paramètres

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

pad

< >

( *args**kwargs )

Regroupe les entrées audio et texte, ainsi que leurs cibles, en un lot rembourré.

Les entrées audio sont remplies par la méthode pad() de SpeechT5FeatureExtractor. Les entrées texte sont remplies par la méthode pad() de SpeechT5Tokenizer.

Les combinaisons d'entrées valides sont :

  • uniquement input_ids
  • uniquement input_values
  • labels uniquement, soit des spectrogrammes log-mel, soit des jetons de texte
  • input_ids et spectrogrammes log-mel labels
  • input_values et les labels de texte

Veuillez consulter la docstring des deux méthodes ci-dessus pour plus d'informations.

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

Paramètres

  • pretrained_model_name_or_path (str ou os.PathLike) — Cela peut être soit :
    • une chaîne de caractères, l'identifiant du modèle d'un feature_extractor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co.
    • un chemin vers un dossier contenant un fichier d’extracteur de caractéristiques enregistré à l’aide de la méthode save_pretrained(), par exemple ./my_model_directory/.
    • un chemin vers un fichier JSON d’extracteur de caractéristiques enregistré fichier, par exemple ./my_model_directory/preprocessor_config.json.
  • **kwargs — Arguments supplémentaires passés à la fois à from_pretrained() et à ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.

Instanciez un processeur associé à un modèle pré-entraîné.

Cette méthode d’appel de classe invoque simplement la méthode from_pretrained() de l’extracteur de caractéristiques, la méthode de la classe ImageProcessingMixin du processeur d’images et la méthode ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained du tokeniseur. Veuillez consulter les docstrings des méthodes ci-dessus pour plus d’informations.

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

Paramètres

  • save_directory (str ou os.PathLike) — Répertoire où le fichier JSON de l'extracteur de caractéristiques et les fichiers du tokenizer seront enregistrés (le répertoire sera créé s'il n'existe pas).
  • push_to_hub (bool, facultatif, par défaut False) — Indique s'il faut ou non pousser votre modèle sur le hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avec repo_id (par défaut, il s'agit du nom de save_directory dans votre espace de noms).
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à la méthode push_to_hub().

Enregistre les attributs de ce processeur (extracteur de caractéristiques, tokeniseur…) dans le répertoire spécifié afin qu’il puisse être rechargé à l’aide de la méthode from_pretrained().

Cette méthode de classe appelle simplement save_pretrained() et save_pretrained(). Veuillez consulter les docstrings des méthodes ci-dessus pour plus d'informations.

batch_decode

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à batch_decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

décoder

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

SpeechT5Model

classe transformers.SpeechT5Model

< >

( config: SpeechT5Configencoder: typing.Optional[torch.nn.Module] = Nonedecoder: typing.Optional[torch.nn.Module] = None )

Paramètres

  • config (SpeechT5Config) — 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.
  • encoder (PreTrainedModel, facultatif) — Le modèle encodeur à utiliser.
  • decoder (PreTrainedModel, facultatif) — Le modèle décodeur à utiliser.

Le modèle SpeechT5 Encoder-Decoder brut, qui produit des états cachés bruts sans aucun pré- ou post-réseau spécifique.

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: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqModelOutput or tuple(torch.Tensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, sequence_length)) — Selon l'encodeur utilisé, les input_values sont soit : des valeurs flottantes de la forme d'onde brute de la parole d'entrée, soit des indices de jetons de la séquence d'entrée dans le vocabulaire, soit des états cachés.
  • attention_mask (torch.LongTensor 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 ?

  • decoder_input_values (torch.Tensor de forme (batch_size, target_sequence_length), facultatif) — Selon le décodeur utilisé, les decoder_input_values sont soit : des valeurs flottantes des caractéristiques de la banque de filtres log-mel extraites de la forme d’onde vocale brute, soit des indices de jetons de la séquence d’entrée du décodeur dans le vocabulaire, soit des états cachés.
  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_values. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez le diagramme 1 de l’article pour plus d’informations sur la stratégie par défaut.

  • encoder_outputs (tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • 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).

  • 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).
  • speaker_embeddings (torch.Tensor de forme (batch_size, config.speaker_embedding_dim), facultatif) — Tenseur contenant les embeddings de locuteur.
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

Seq2SeqModelOutput ou tuple(torch.Tensor)

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

La méthode forward du SpeechT5Model 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 décodeur 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 (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. 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 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.

  • decoder_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 décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.

  • decoder_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 d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_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 d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

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

  • encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.

  • encoder_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 d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

SpeechT5ForSpeechToText

classe transformers.SpeechT5ForSpeechToText

< >

( config: SpeechT5Config )

Paramètres

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

Modèle SpeechT5 avec un encodeur audio et un décodeur texte.

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: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, sequence_length)) — Valeurs flottantes de la forme d'onde brute de la parole d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio .flac ou .wav dans un tableau de type list[float], un numpy.ndarray ou un torch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau en input_values, le SpeechT5Processor doit être utilisé pour le bourrage et la conversion en un tenseur de type torch.Tensor. Voir SpeechT5Processor.call() pour plus de détails.
  • attention_mask (torch.LongTensor 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 ?

  • decoder_input_ids (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de SpeechT5Tokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? SpeechT5 utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values).

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

    Quelles sont les identifiants d'entrée du décodeur ?

    SpeechT5 utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n’entrer que les derniers decoder_input_ids (voir past_key_values).

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_values. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez le diagramme 1 de l’article pour plus d’informations sur la stratégie par défaut.

  • encoder_outputs (tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • 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).

  • 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).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation du langage. Les indices doivent être dans [0, ..., config.vocab_size] ou -100 (voir la input_ids docstring). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].

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

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

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

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

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

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage.

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

  • past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. 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 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.

  • decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.

  • decoder_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 d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_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 d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

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

  • encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.

  • encoder_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 d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToText
>>> from datasets import load_dataset

>>> dataset = load_dataset(
...     "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
... )  # doctest: +IGNORE_RESULT
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_asr")
>>> model = SpeechT5ForSpeechToText.from_pretrained("microsoft/speecht5_asr")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> predicted_ids = model.generate(**inputs, max_length=100)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
>>> inputs["labels"] = processor(text_target=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
19.68

SpeechT5ForTextToSpeech

classe transformers.SpeechT5ForTextToSpeech

< >

( config: SpeechT5Config )

Paramètres

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

Modèle SpeechT5 avec un encodeur de texte et un décodeur de parole.

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] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonestop_labels: typing.Optional[torch.Tensor] = None**kwargs ) → Seq2SeqSpectrogramOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire.

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

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

  • attention_mask (torch.LongTensor 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 ?

  • decoder_input_values (torch.Tensor de forme (batch_size, sequence_length, config.num_mel_bins)) — Valeurs flottantes du spectrogramme mel d'entrée.

    SpeechT5 utilise un spectre entièrement nul comme jeton de départ pour la génération de decoder_input_values. Si past_key_values est utilisé, il est facultatif de n’entrer que les derniers decoder_input_values (voir past_key_values).

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_values. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez le diagramme 1 de l’article pour plus d’informations sur la stratégie par défaut.

  • encoder_outputs (tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • 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).

  • 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).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • speaker_embeddings (torch.Tensor de forme (batch_size, config.speaker_embedding_dim), facultatif) — Tenseur contenant les embeddings de locuteur.
  • labels (torch.Tensor de forme (batch_size, sequence_length, config.num_mel_bins), facultatif) — Valeurs flottantes du spectrogramme mel cible. Les pas de temps définis à -100.0 sont ignorés (masqués) pour le calcul de la perte. Les spectrogrammes peuvent être obtenus à l'aide de SpeechT5Processor. Voir SpeechT5Processor.call() pour plus de détails.
  • stop_labels (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Tenseur binaire indiquant la position du jeton d'arrêt dans la séquence.

Retourne

Seq2SeqSpectrogramOutput ou tuple(torch.Tensor)

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

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

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

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de génération de spectrogramme.

  • spectrogram (torch.Tensor de forme (batch_size, sequence_length, num_bins)) — Le spectrogramme prédit.

  • past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. 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 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.

  • decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.

  • decoder_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 d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_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 d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

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

  • encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.

  • encoder_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 d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, set_seed
>>> import torch

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
>>> model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([15872])

generate

< >

( input_ids: LongTensorattention_mask: typing.Optional[torch.LongTensor] = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonethreshold: float = 0.5minlenratio: float = 0.0maxlenratio: float = 20.0vocoder: typing.Optional[torch.nn.Module] = Noneoutput_cross_attentions: bool = Falsereturn_output_lengths: bool = False**kwargs ) → tuple(torch.Tensor) comprising various elements depending on the inputs

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire.

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

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

  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length)) — Masque d'attention issu du tokenizer, requis pour l'inférence par lots afin d'indiquer au modèle où ignorer les jetons de bourrage (padding) des input_ids.
  • speaker_embeddings (torch.Tensor de forme (batch_size, config.speaker_embedding_dim), facultatif) — Tenseur contenant les embeddings de locuteur.
  • threshold (float, facultatif, valeur par défaut 0.5) — La séquence générée se termine lorsque la probabilité du jeton d'arrêt prédit dépasse cette valeur.
  • minlenratio (float, facultatif, valeur par défaut 0.0) — Utilisé pour calculer la longueur minimale requise de la séquence de sortie.
  • maxlenratio (float, facultatif, valeur par défaut 20.0) — Utilisé pour calculer la longueur maximale autorisée de la séquence de sortie.
  • vocoder (nn.Module, facultatif) — Le vocoder qui convertit le spectrogramme mel en forme d'onde vocale. Si None, la sortie est le spectrogramme mel.
  • output_cross_attentions (bool, facultatif, valeur par défaut False) — Indique s'il faut retourner les tenseurs d'attention des couches d'attention croisée du décodeur.
  • return_output_lengths (bool, facultatif, par défaut False) — Indique s'il faut retourner les longueurs concrètes des spectrogrammes/formes d'onde.

Retourne

tuple(torch.Tensor) comprenant divers éléments selon les entrées

  • lorsque return_output_lengths est False
    • spectrogram (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) torch.Tensor de forme (output_sequence_length, config.num_mel_bins) — Le spectrogramme log-mel prédit.
    • waveform (facultatif, renvoyé lorsqu'un vocoder est fourni) torch.Tensor de forme (num_frames,) — Le signal audio prédit.
    • cross_attentions (facultatif, renvoyé lorsque output_cross_attentions est True) torch.Tensor de forme (config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) — Les sorties des couches d'attention croisée du décodeur.
  • lorsque return_output_lengths est True
    • spectrogrammes (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) torch.Tensor de forme (batch_size, output_sequence_length, config.num_mel_bins) — Les spectrogrammes log-mel prédits, remplis jusqu'à la longueur maximale.
    • spectrogram_lengths (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) list[Int] — Une liste de toutes les longueurs concrètes de chaque spectrogramme.
    • formes d'onde (facultatif, renvoyé lorsqu'un vocoder est fourni) torch.Tensor de forme (batch_size, num_frames) — Les formes d'onde de la parole prédites, remplies jusqu'à la longueur maximale.
    • waveform_lengths (facultatif, renvoyé lorsqu'un vocoder est fourni) list[Int] — Une liste de toutes les longueurs concrètes de chaque forme d'onde.
    • cross_attentions (facultatif, renvoyé lorsque output_cross_attentions est True) torch.Tensor de forme (batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) — Les sorties des couches d'attention croisée du décodeur.

Convertit une séquence de jetons d'entrée en une séquence de spectrogrammes mel, qui sont ensuite transformés en une forme d'onde vocale à l'aide d'un vocoder.

SpeechT5ForSpeechToSpeech

classe transformers.SpeechT5ForSpeechToSpeech

< >

( config: SpeechT5Config )

Paramètres

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

Modèle SpeechT5 avec un encodeur de parole et un décodeur de parole.

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: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonestop_labels: typing.Optional[torch.Tensor] = None**kwargs ) → Seq2SeqSpectrogramOutput or tuple(torch.Tensor)

Paramètres

  • input_values (torch.Tensor de forme (batch_size, sequence_length)) — Valeurs flottantes de la forme d'onde brute de la parole d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio .flac ou .wav dans un tableau de type list[float], un numpy.ndarray ou un torch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau en input_values, le SpeechT5Processor doit être utilisé pour le bourrage et la conversion en tenseur de type torch.Tensor. Voir SpeechT5Processor.call() pour plus de détails.
  • attention_mask (torch.LongTensor 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 ?

  • decoder_input_values (torch.Tensor de forme (batch_size, sequence_length, config.num_mel_bins)) — Valeurs flottantes du spectrogramme mel d'entrée.

    SpeechT5 utilise un spectre entièrement nul comme jeton de départ pour la génération de decoder_input_values. Si past_key_values est utilisé, il est facultatif de n’entrer que les derniers decoder_input_values (voir past_key_values).

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_values. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire SpeechT5Decoder._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez le diagramme 1 de l’article pour plus d’informations sur la stratégie par défaut.

  • encoder_outputs (tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • 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).

  • 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).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • speaker_embeddings (torch.Tensor de forme (batch_size, config.speaker_embedding_dim), facultatif) — Tenseur contenant les embeddings de locuteur.
  • labels (torch.Tensor de forme (batch_size, sequence_length, config.num_mel_bins), facultatif) — Valeurs flottantes du spectrogramme mel cible. Les spectrogrammes peuvent être obtenus à l'aide de SpeechT5Processor. Voir SpeechT5Processor.call() pour plus de détails.
  • stop_labels (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Tenseur binaire indiquant la position du jeton d'arrêt dans la séquence.

Retourne

Seq2SeqSpectrogramOutput ou tuple(torch.Tensor)

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

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

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

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de génération de spectrogramme.

  • spectrogram (torch.Tensor de forme (batch_size, sequence_length, num_bins)) — Le spectrogramme prédit.

  • past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. 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 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.

  • decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.

  • decoder_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 d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_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 d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

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

  • encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.

  • encoder_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 d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToSpeech, SpeechT5HifiGan, set_seed
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset(
...     "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
... )  # doctest: +IGNORE_RESULT
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_vc")
>>> model = SpeechT5ForSpeechToSpeech.from_pretrained("microsoft/speecht5_vc")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate_speech(inputs["input_values"], speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([77824])

generate_speech

< >

( input_values: Tensorspeaker_embeddings: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonethreshold: float = 0.5minlenratio: float = 0.0maxlenratio: float = 20.0vocoder: typing.Optional[torch.nn.Module] = Noneoutput_cross_attentions: bool = Falsereturn_output_lengths: bool = False ) → tuple(torch.Tensor) comprising various elements depending on the inputs

Paramètres

  • input_values (torch.Tensor de forme (batch_size, sequence_length)) — Valeurs flottantes de la forme d'onde brute de la parole d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio .flac ou .wav dans un tableau de type list[float], numpy.ndarray ou torch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau en input_values, SpeechT5Processor doit être utilisé pour le bourrage et la conversion en un tenseur de type torch.Tensor. Voir SpeechT5Processor.call() pour plus de détails.

    Les valeurs peuvent être obtenues en chargeant un fichier audio .flac ou .wav dans un tableau de type list[float], un numpy.ndarray ou un torch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau en input_values, le SpeechT5Processor doit être utilisé pour le padding et la conversion en un tenseur de type torch.Tensor. Consultez SpeechT5Processor.call() pour plus de détails.

  • speaker_embeddings (torch.Tensor de forme (batch_size, config.speaker_embedding_dim), facultatif) — Tenseur contenant les embeddings de locuteur.
  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'effectuer la convolution et l'attention sur les indices des jetons de bourrage. Valeurs du masque sélectionnées 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 ?

  • threshold (float, facultatif, valeur par défaut 0.5) — La séquence générée se termine lorsque la probabilité du jeton d'arrêt prédit dépasse cette valeur.
  • minlenratio (float, facultatif, valeur par défaut 0.0) — Utilisé pour calculer la longueur minimale requise de la séquence de sortie.
  • maxlenratio (float, facultatif, valeur par défaut 20.0) — Utilisé pour calculer la longueur maximale autorisée de la séquence de sortie.
  • vocoder (nn.Module, facultatif, par défaut None) — Le vocodeur qui convertit le spectrogramme de Mel en forme d'onde vocale. Si None, la sortie est le spectrogramme de Mel.
  • output_cross_attentions (bool, facultatif, valeur par défaut False) — Indique s'il faut retourner les tenseurs d'attention des couches d'attention croisée du décodeur.
  • return_output_lengths (bool, facultatif, par défaut False) — Indique s'il faut retourner les longueurs concrètes des spectrogrammes/formes d'onde.

Retourne

tuple(torch.Tensor) comprenant divers éléments selon les entrées

  • lorsque return_output_lengths est False
    • spectrogram (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) torch.Tensor de forme (output_sequence_length, config.num_mel_bins) — Le spectrogramme log-mel prédit.
    • waveform (facultatif, renvoyé lorsqu'un vocoder est fourni) torch.Tensor de forme (num_frames,) — Le signal audio prédit.
    • cross_attentions (facultatif, renvoyé lorsque output_cross_attentions est True) torch.Tensor de forme (config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) — Les sorties des couches d'attention croisée du décodeur.
  • lorsque return_output_lengths est True
    • spectrogrammes (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) torch.Tensor de forme (batch_size, output_sequence_length, config.num_mel_bins) — Les spectrogrammes log-mel prédits, remplis jusqu'à la longueur maximale.
    • spectrogram_lengths (facultatif, renvoyé lorsqu'aucun vocoder n'est fourni) list[Int] — Une liste de toutes les longueurs concrètes de chaque spectrogramme.
    • formes d'onde (facultatif, renvoyé lorsqu'un vocoder est fourni) torch.Tensor de forme (batch_size, num_frames) — Les formes d'onde de la parole prédites, remplies jusqu'à la longueur maximale.
    • waveform_lengths (facultatif, renvoyé lorsqu'un vocoder est fourni) list[Int] — Une liste de toutes les longueurs concrètes de chaque forme d'onde.
    • cross_attentions (facultatif, renvoyé lorsque output_cross_attentions est True) torch.Tensor de forme (batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) — Les sorties des couches d'attention croisée du décodeur.

Convertit une forme d’onde vocale brute en une séquence de spectrogrammes de mel, qui sont ensuite reconvertis en forme d’onde vocale à l’aide d’un vocoder.

SpeechT5HifiGan

classe transformers.SpeechT5HifiGan

< >

( config: SpeechT5HifiGanConfig )

Paramètres

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

Vocodeur HiFi-GAN.

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

< >

( spectrogram: Tensor**kwargs ) → torch.Tensor

Paramètres

  • spectrogram (torch.Tensor) — Tenseur contenant les spectrogrammes log-mel. Peut être groupé (batched) et de forme (batch_size, sequence_length, config.model_in_dim), ou non groupé et de forme (sequence_length, config.model_in_dim).

Retourne

torch.Tensor

Tenseur contenant la forme d'onde de la parole. Si le spectrogramme d'entrée est groupé (batched), il aura la forme (batch_size, num_frames,). S'il n'est pas groupé, il aura la forme (num_frames,).

Convertit un spectrogramme log-mel en forme d’onde vocale. Le passage d’un lot de spectrogrammes log-mel renvoie un lot de formes d’onde vocales. Le passage d’un spectrogramme log-mel unique, non loti, renvoie une forme d’onde vocale unique, non lotie.

Update on GitHub

←Speech2Text UniSpeech→