Transformers documentation
Wav2Vec2-Conformer
Ce modèle a été publié dans les papiers HF le 2020-10-11 et a été contribué à Hugging Face Transformers le 2022-05-17.
Wav2Vec2-Conformer
Aperçu
Le Wav2Vec2-Conformer a été ajouté à une version mise à jour de fairseq S2T : Fast Speech-to-Text Modeling with fairseq par Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko et Juan Pino.
Les résultats officiels du modèle figurent dans le Tableau 3 et le Tableau 4 de l’article.
Les poids de Wav2Vec2-Conformer ont été publiés par l'équipe Meta AI au sein de la bibliothèque Fairseq.
Ce modèle a été contribué par patrickvonplaten. Le code d’origine peut être trouvé ici.
Note : Meta (FAIR) a publié une nouvelle version de Wav2Vec2-BERT 2.0 - elle est pré-entraînée sur 4,5 millions d'heures d'audio. Nous recommandons en particulier de l'utiliser pour les tâches de fine-tuning, par exemple selon ce guide.
Conseils d'utilisation
- Wav2Vec2-Conformer suit la même architecture que Wav2Vec2, mais remplace le bloc Attention par un bloc Conformer tel qu'introduit dans Conformer: Convolution-augmented Transformer for Speech Recognition.
- Pour un nombre de couches identique, Wav2Vec2-Conformer nécessite plus de paramètres que Wav2Vec2, mais offre également un taux d'erreur par mot amélioré.
- Wav2Vec2-Conformer utilise le même tokenizer et le même feature extractor que Wav2Vec2.
- Wav2Vec2-Conformer peut utiliser soit aucun encodage de position relative, soit des encodages de position de type Transformer-XL, soit des encodages de position rotatifs, en définissant la valeur appropriée de
config.position_embeddings_type.
Ressources
- Guide de la tâche de classification audio
- Guide de la tâche de reconnaissance automatique de la parole
Wav2Vec2ConformerConfig
classe transformers.Wav2Vec2ConformerConfig
< source >( 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 = Nonevocab_size: int | None = Nonehidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1feat_proj_dropout: float | int = 0.0feat_quantizer_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05feat_extract_norm: str = 'group'feat_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 = 0num_codevectors_per_group: int = 320num_codevector_groups: int = 2contrastive_logits_temperature: float = 0.1num_negatives: int = 100codevector_dim: int = 256proj_codevector_dim: int = 256diversity_loss_weight: float = 0.1ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500)tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1)tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1)xvector_output_dim: int = 512pad_token_id: int | None = 0bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2add_adapter: bool = Falseadapter_kernel_size: int = 3adapter_stride: int = 2num_adapter_layers: int = 3output_hidden_size: int | None = Noneposition_embeddings_type: str | None = 'relative'rotary_embedding_base: int = 10000max_source_positions: int = 5000conv_depthwise_kernel_size: int = 31conformer_conv_dropout: float | int = 0.1 )
Paramètres
- vocab_size (
int, facultatif) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - intermediate_size (
int, facultatif, par défaut3072) — Dimension des représentations du MLP. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - hidden_dropout (
Union[float, int], facultatif, valeur par défaut0.1) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler. - activation_dropout (
Union[float, int], facultatif, valeur par défaut0.1) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - feat_proj_dropout (
float, facultatif, valeur par défaut 0.0) — Probabilité de dropout pour la sortie de l'encodeur de caractéristiques. - feat_quantizer_dropout (
float, facultatif, valeur par défaut 0.0) — Probabilité de dropout appliquée à la sortie de l’encodeur de caractéristiques utilisée par le quantiseur. - final_dropout (
float, facultatif, par défaut 0.1) — Probabilité de dropout pour la couche de projection finale de Wav2Vec2ConformerForCTC. - layerdrop (
Union[float, int], facultatif, par défaut0.1) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - initializer_range (
float, facultatif, par défaut0.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éfaut1e-05) — L'épsilon utilisé par les couches de normalisation de couche. - feat_extract_norm (
str, facultatif, par défaut"group") — La normalisation à appliquer aux couches de convolution 1D de l'encodeur de caractéristiques. 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_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]oulist[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 dans l'encodeur de caractéristiques. La longueur de conv_dim définit le nombre de couches de convolution 1D. - conv_stride (
tuple[int]oulist[int], facultatif, par défaut(5, 2, 2, 2, 2, 2, 2)) — Un tuple d'entiers définissant le pas de chaque couche convolutive 1D dans l'encodeur de caractéristiques. La longueur de conv_stride définit le nombre de couches convolutives et doit correspondre à la longueur de conv_dim. - conv_kernel (
tuple[int]oulist[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 dans l'encodeur de caractéristiques. 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éfautFalse) — 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, par défautTrue) — Indique s'il faut appliquer l'augmentation de données SpecAugment aux sorties de l'encodeur de caractéristiques. 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 ifapply_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 longueurmask_feature_lengthgénérés le long de l’axe temporel, à chaque étape temporelle, indépendamment demask_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 ifapply_spec_augment is True`. - mask_feature_prob (
Union[float, int], facultatif, valeur par défaut0.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èremask_feature_prob*len(feature_axis)/mask_time_lengthmasques 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 êtreprob_vector_start*mask_feature_length. Notez que les chevauchements peuvent diminuer le pourcentage réel de vecteurs masqués. Cela n'est pertinent que siapply_spec_augmentestTrue. - 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 longueurmask_feature_lengthgénérés le long de l’axe des caractéristiques, à chaque étape, indépendamment demask_feature_prob. Ne concerne que le cas où ”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” - num_codevectors_per_group (
int, facultatif, valeur par défaut : 320) — Nombre d'entrées dans chaque codebook de quantification (groupe). - num_codevectors_per_group (
int, facultatif, valeur par défaut : 320) — Nombre d'entrées dans chaque codebook de quantification (groupe). - num_codevector_groups (
int, facultatif, valeur par défaut : 2) — Nombre de groupes de codevectors pour la quantification par codevectors produit. - contrastive_logits_temperature (
float, facultatif, valeur par défaut 0,1) — La température kappa dans la perte contrastive. - num_negatives (
int, facultatif, valeur par défaut : 100) — Nombre d'échantillons négatifs pour la perte contrastive. - codevector_dim (
int, facultatif, valeur par défaut : 256) — Dimension des vecteurs de caractéristiques quantifiés. - proj_codevector_dim (
int, facultatif, valeur par défaut : 256) — Dimension de la projection finale des fonctionnalités quantifiées et des fonctionnalités du transformeur. - diversity_loss_weight (
int, facultatif, valeur par défaut 0.1) — Le poids de la composante de perte de diversité du codebook. - ctc_loss_reduction (
str, facultatif, par défautsum) — Spécifie la réduction à appliquer à la sortie detorch.nn.CTCLoss. N'est pertinent que lors de l'entraînement. - ctc_zero_infinity (
bool, facultatif, valeur par défautFalse) — Indique s'il faut mettre à zéro les pertes infinies et les gradients associés detorch.nn.CTCLoss. Les pertes infinies se produisent principalement lorsque les entrées sont trop courtes pour être alignées sur les cibles. Ne concerne que l'entraînement d'une instance de Wav2Vec2ConformerForCTC. - use_weighted_layer_sum (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser une moyenne pondérée des sorties des couches avec des poids appris. Ne concerne que l'utilisation d'une instance de Wav2Vec2ConformerForSequenceClassification. - classifier_proj_size (
int, facultatif, valeur par défaut 256) — Dimension de la projection avant le pooling par moyenne des jetons pour la classification. - tdnn_dim (
tuple[int]oulist[int], facultatif, par défaut(512, 512, 512, 512, 1500)) — Un tuple d'entiers définissant le nombre de canaux de sortie de chaque couche de convolution 1D du module TDNN du modèle XVector. La longueur de tdnn_dim définit le nombre de couches TDNN. - tdnn_kernel (
tuple[int]oulist[int], facultatif, par défaut(5, 3, 3, 1, 1)) — Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du module TDNN du modèle XVector. La longueur de tdnn_kernel doit correspondre à la longueur de tdnn_dim. - tdnn_dilation (
tuple[int]oulist[int], facultatif, par défaut(1, 2, 3, 1, 1)) — Un tuple d'entiers définissant le facteur de dilatation de chaque couche convolutive 1D du module TDNN du modèle XVector. La longueur de tdnn_dilation doit correspondre à la longueur de tdnn_dim. - xvector_output_dim (
int, facultatif, par défaut 512) — Dimension des vecteurs d'incorporation XVector. - pad_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - add_adapter (
bool, facultatif, valeur par défautFalse) — Indique si un réseau convolutif doit être empilé au-dessus de l'encodeur Wav2Vec2Conformer. Peut être très utile pour amorcer Wav2Vec2Conformer pour les modèles SpeechEncoderDecoder. - adapter_kernel_size (
int, facultatif, valeur par défaut 3) — Taille du noyau des couches convolutives du réseau adaptateur. Ne concerne que le cas oùadd_adapter is True. - adapter_stride (
int, facultatif, valeur par défaut 2) — Pas des couches de convolution dans le réseau adaptateur. Ne concerne que le cas oùadd_adapter is True. - num_adapter_layers (
int, facultatif, valeur par défaut 3) — Nombre de couches de convolution à utiliser dans le réseau adaptateur. Ne concerne que le cas oùadd_adapter is True. - output_hidden_size (
int, facultatif) — Dimensionnalité de la couche de sortie de l'encodeur. Si non définie, cette valeur est par défaut hidden-size. N'est pertinent que siadd_adapter is True. - position_embeddings_type (
str, facultatif, par défaut"relative") — Peut être défini surrelativeourotarypour les embeddings de position relatifs ou rotatifs, respectivement. S'il est laissé àNone, aucun embedding de position relatif n'est appliqué. - rotary_embedding_base (
int, facultatif, valeur par défaut : 10000) — Si des embeddings de position"rotary"sont utilisés, définit la taille de la base de l'embedding. - max_source_positions (
int, facultatif, par défaut 5000) — si des embeddings de position"relative"sont utilisés, définit les positions d’entrée source maximales. - conv_depthwise_kernel_size (
int, facultatif, valeur par défaut : 31) — Taille du noyau de la couche convolutive 1D en profondeur (depthwise) dans les blocs Conformer. - conformer_conv_dropout (
float, facultatif, valeur par défaut 0.1) — Probabilité de dropout pour toutes les couches de convolution dans les blocs Conformer.
Il s’agit de la classe de configuration destinée à stocker la configuration d’un Wav2Vec2 ConformerModel. Elle est utilisée pour instancier un modèle Wav2Vec2 Conformer en fonction des arguments spécifiés, définissant ainsi l’architecture du modèle. L’instanciation d’une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/wav2vec2-conformer-rel-pos-large
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 Wav2Vec2ConformerConfig, Wav2Vec2ConformerModel
>>> # Initializing a Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> configuration = Wav2Vec2ConformerConfig()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> model = Wav2Vec2ConformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSorties spécifiques de Wav2Vec2Conformer
classe transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneprojected_states: typing.Optional[torch.Tensor] = Noneprojected_quantized_states: typing.Optional[torch.Tensor] = Nonecodevector_perplexity: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecontrastive_loss: typing.Optional[torch.Tensor] = Nonediversity_loss: typing.Optional[torch.Tensor] = None )
Paramètres
- loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the official paper. - projected_states (
torch.Tensorde forme(batch_size, sequence_length, config.proj_codevector_dim)) — États cachés du modèle projetés sur config.proj_codevector_dim, utilisables pour prédire les états quantifiés masqués projetés. - projected_quantized_states (
torch.Tensorde forme(batch_size, sequence_length, config.proj_codevector_dim)) — Vecteurs de caractéristiques extraits et quantifiés, projetés sur config.proj_codevector_dim, représentant les vecteurs cibles positifs pour la perte contrastive. - codevector_perplexity (
torch.Tensorde forme(1,)) — La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook. - hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- contrastive_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The contrastive loss (L_m) as stated in the official paper. - diversity_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The diversity loss (L_d) as stated in the official paper.
Type de sortie de Wav2Vec2ConformerForPreTraining, avec états cachés et attentions potentiels.
Wav2Vec2ConformerModel
classe transformers.Wav2Vec2ConformerModel
< source >( config: Wav2Vec2ConformerConfig )
Paramètres
- config (Wav2Vec2ConformerConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Wav2Vec2 Conformer brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2BaseModelOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Valeurs flottantes de la forme d’onde brute de l’entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, il faut utiliser AutoProcessor pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. Voir Wav2Vec2Processor.call() pour plus de détails. - attention_mask (
torch.Tensorde 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.
- mask_time_indices (
torch.BoolTensorde forme(batch_size, sequence_length), facultatif) — Indices à masquer pour les fonctionnalités extraites afin de calculer la perte contrastive. En mode d’entraînement, le modèle apprend à prédire les fonctionnalités extraites masquées dans l’espace config.proj_codevector_dim.
Retourne
Wav2Vec2BaseModelOutput ou tuple(torch.Tensor)
Un Wav2Vec2BaseModelOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerModel 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
Moduleplutô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.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.extract_features (
torch.Tensorde forme(batch_size, sequence_length, conv_dim[-1])) — Séquence de vecteurs de caractéristiques extraits de la dernière couche convolutive du modèle.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Wav2Vec2ConformerForCTC
classe transformers.Wav2Vec2ConformerForCTC
< source >( config: Wav2Vec2ConformerConfigtarget_lang: str | None = None )
Paramètres
- config (Wav2Vec2ConformerConfig) — 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.
- target_lang (
str, facultatif) — Identifiant de langue des poids de l’adaptateur. Les poids de l’adaptateur sont stockés au format adapter..safetensors ou adapter. .bin. Pertinent uniquement lors de l’utilisation d’une instance de UniSpeechSatForCTC avec des adaptateurs. La valeur par défaut est « eng ».
Modèle Wav2Vec2Conformer avec une tête de language modeling pour la Classification Temporelle Connectiviste (CTC).
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Valeurs flottantes de la forme d’onde brute de l’entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, il faut utiliser AutoProcessor pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. Voir Wav2Vec2Processor.call() pour plus de détails. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde forme(batch_size, target_length), facultatif) — Étiquettes pour la classification temporelle connexionniste. Notez quetarget_lengthdoit être inférieur ou égal à la longueur de séquence des logits de sortie. Les indices sont sélectionnés dans[-100, 0, ..., config.vocab_size - 1]. Toutes les étiquettes définies sur-100sont ignorées (masquées) ; la perte n'est calculée que pour les étiquettes comprises dans[0, ..., config.vocab_size - 1].
Retourne
CausalLMOutput ou tuple(torch.Tensor)
Un CausalLMOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerForCTC 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde 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).hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoProcessor, Wav2Vec2ConformerForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForCTC.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...Wav2Vec2ConformerForSequenceClassification
classe transformers.Wav2Vec2ConformerForSequenceClassification
< source >( config: Wav2Vec2ConformerConfig )
Paramètres
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer avec une tête de classification de séquence au sommet (une couche linéaire sur la sortie agrégée) pour des tâches telles que SUPERB Keyword Spotting.
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde 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.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, le AutoProcessor doit être utilisé pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. VoirWav2Vec2ConformerProcessor.__call__pour plus de détails. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée).
Retourne
SequenceClassifierOutput ou tuple(torch.Tensor)
Un SequenceClassifierOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerForSequenceClassification 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple de classification mono-étiquette :
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ConformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemple de classification multi-étiquettes :
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ConformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained(
... "facebook/wav2vec2-conformer-rel-pos-large", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossWav2Vec2ConformerForAudioFrameClassification
classe transformers.Wav2Vec2ConformerForAudioFrameClassification
< source >( config: Wav2Vec2ConformerConfig )
Paramètres
- config (Wav2Vec2ConformerConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Wav2Vec2 Conformer avec une tête de classification par trame au sommet, pour des tâches telles que la diarisation de locuteurs.
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde 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.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, le AutoProcessor doit être utilisé pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. VoirWav2Vec2ConformerProcessor.__call__pour plus de détails. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée).
Retourne
TokenClassifierOutput ou tuple(torch.Tensor)
Un TokenClassifierOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerForAudioFrameClassification 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForAudioFrameClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...Wav2Vec2ConformerForXVector
classe transformers.Wav2Vec2ConformerForXVector
< source >( config: Wav2Vec2ConformerConfig )
Paramètres
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer avec une tête d'extraction de caractéristiques XVector au sommet, pour des tâches telles que la vérification de l'orateur.
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → XVectorOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde 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.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, le AutoProcessor doit être utilisé pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. VoirWav2Vec2ConformerProcessor.__call__pour plus de détails. - attention_mask (
torch.Tensorde 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.
- labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée).
Retourne
XVectorOutput ou tuple(torch.Tensor)
Un XVectorOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerForXVector 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, config.xvector_output_dim)) — États cachés de classification avant AMSoftmax.embeddings (
torch.Tensorde forme(batch_size, config.xvector_output_dim)) — Embeddings d'énoncés utilisés pour la récupération basée sur la similarité vectorielle.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForXVector.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
... embeddings = model(**inputs).embeddings
>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7 # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
... print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...Wav2Vec2ConformerForPreTraining
classe transformers.Wav2Vec2ConformerForPreTraining
< source >( config: Wav2Vec2ConformerConfig )
Paramètres
- config (Wav2Vec2ConformerConfig) — 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 Wav2Vec2Conformer avec un quantificateur et une tête VQ au sommet.
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
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.BoolTensor] = Nonesampled_negative_indices: typing.Optional[torch.BoolTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2ConformerForPreTrainingOutput or tuple(torch.Tensor)
Paramètres
- input_values (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Valeurs flottantes de la forme d’onde brute de l’entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, il faut utiliser AutoProcessor pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. Voir Wav2Vec2Processor.call() pour plus de détails. - attention_mask (
torch.Tensorde 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.
- mask_time_indices (
torch.BoolTensorde forme(batch_size, sequence_length), facultatif) — Indices à masquer pour les fonctionnalités extraites afin de calculer la perte contrastive. En mode d’entraînement, le modèle apprend à prédire les fonctionnalités extraites masquées dans l’espace config.proj_codevector_dim. - sampled_negative_indices (
torch.BoolTensorde forme(batch_size, sequence_length, num_negatives), facultatif) — Indices indiquant quels vecteurs cibles quantifiés sont utilisés comme vecteurs négatifs échantillonnés dans la perte contrastive. Entrée requise pour la pré-formation.
Retourne
Wav2Vec2ConformerForPreTrainingOutput ou tuple(torch.Tensor)
Un Wav2Vec2ConformerForPreTrainingOutput 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 (Wav2Vec2ConformerConfig) et des entrées.
La méthode forward de Wav2Vec2ConformerForPreTraining 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
Moduleplutô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 (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — Perte totale, définie comme la somme de la perte contrastive (L_m) et de la perte de diversité (L_d), conformément à l'article officiel.projected_states (
torch.Tensorde forme(batch_size, sequence_length, config.proj_codevector_dim)) — États cachés du modèle projetés sur config.proj_codevector_dim, utilisables pour prédire les états quantifiés masqués projetés.projected_quantized_states (
torch.Tensorde forme(batch_size, sequence_length, config.proj_codevector_dim)) — Vecteurs de caractéristiques extraits quantifiés projetés sur config.proj_codevector_dim, représentant les vecteurs cibles positifs pour la perte contrastive.codevector_perplexity (
torch.Tensorde forme(1,)) — La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook.hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
contrastive_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — La perte contrastive (L_m) telle que définie dans l'article officiel.diversity_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — La perte de diversité (L_d) telle que définie dans l'article officiel.
Exemple :
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForPreTraining
>>> from transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2_conformer-base")
>>> model = Wav2Vec2ConformerForPreTraining.from_pretrained("facebook/wav2vec2_conformer-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
... shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
... features_shape=(batch_size, sequence_length),
... num_negatives=model.config.num_negatives,
... mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
... data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )
>>> with torch.no_grad():
... outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)
>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)
>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
... input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss