# UniSpeech-SAT

## Aperçu

Le modèle UniSpeech-SAT a été proposé dans [UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware Pre-Training](https://huggingface.co/papers/2110.05752) par Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.

L'abstract de l'article est le suivant :

*L’apprentissage auto-supervisé (SSL) est un objectif de longue date pour le traitement de la parole, car il exploite de grandes quantités de données non étiquetées et évite l’étiquetage humain intensif. Ces dernières années ont été marquées par de grands succès dans l’application de l’apprentissage auto-supervisé à la reconnaissance vocale, tandis que les explorations de l’application du SSL à la modélisation des caractéristiques des locuteurs sont restées limitées. Dans cet article, nous visons à améliorer le cadre SSL existant pour l’apprentissage de représentations de locuteurs. Deux méthodes sont introduites pour renforcer l’extraction non supervisée d’informations sur le locuteur. Premièrement, nous appliquons l’apprentissage multi-tâches au cadre SSL actuel, en intégrant la perte contrastive par énoncé à la fonction objectif SSL. Deuxièmement, pour une meilleure discrimination des locuteurs, nous proposons une stratégie de mélange d’énoncés pour l’augmentation de données, dans laquelle des énoncés superposés supplémentaires sont créés de manière non supervisée et incorporés pendant l’entraînement. Nous intégrons les méthodes proposées dans le cadre HuBERT. Les résultats expérimentaux sur le benchmark SUPERB montrent que le système proposé atteint des performances de pointe en apprentissage de représentations universelles, en particulier pour les tâches orientées vers l’identification du locuteur. Une étude d’ablation est réalisée pour vérifier l’efficacité de chaque méthode proposée. Enfin, nous augmentons la taille du jeu de données d’entraînement à 94 000 heures de données audio publiques et obtenons une amélioration supplémentaire des performances sur toutes les tâches SUPERB.*

Ce modèle a été contribué par [patrickvonplaten](https://huggingface.co/patrickvonplaten). Le code des auteurs est disponible [ici](https://github.com/microsoft/UniSpeech/tree/main/UniSpeech-SAT).

## Conseils d'utilisation

- UniSpeechSat est un modèle de parole qui accepte un tableau de nombres flottants correspondant à la forme d’onde brute du signal de parole. Veuillez utiliser [Wav2Vec2Processor](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor) pour l’extraction des caractéristiques.
- Le modèle UniSpeechSat peut être affiné à l'aide de la classification temporelle connexionniste (CTC), de sorte que la sortie du modèle doit être décodée à l'aide de [Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).
- UniSpeechSat obtient de très bons résultats sur les tâches de vérification d’orateur, d’identification d’orateur et de diarisation d’orateur.

## Ressources

- [Guide de la tâche de classification audio](../tasks/audio_classification)
- [Guide de la tâche de reconnaissance automatique de la parole](../tasks/asr)

## UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

#### transformers.UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

```python
transformers.UniSpeechSatConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, feat_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 = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, do_stable_layer_norm: bool = False, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, tdnn_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 = 512, pad_token_id: int = 0, bos_token_id: int = 1, eos_token_id: int = 2, num_clusters: int = 504)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/configuration_unispeech_sat.py#L27)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `32`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La 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éfaut `0.1`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.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) : La probabilité de dropout pour la sortie de l'encodeur de caractéristiques utilisée par le quantificateur.

final_dropout (`float`, *facultatif*, valeur par défaut 0,1) : La probabilité de dropout pour la couche de projection finale de [UniSpeechSatForCTC](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de LayerDrop. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

feat_extract_norm (`str`, *facultatif*, valeur 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]` ou `list[int]`, *facultatif*, valeur 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 convolutive 1D dans l'encodeur de caractéristiques. La longueur de *conv_dim* définit le nombre de couches convolutives 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 de convolution 1D dans l'encodeur de caractéristiques. La longueur de *conv_stride* définit le nombre de couches de convolution et doit correspondre à la longueur de *conv_dim*.

conv_kernel (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `(10, 3, 3, 3, 3, 2, 2)`) : 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é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'incorporations positionnelles convolutives. Définit la taille du noyau de la couche d'incorporations positionnelles convolutives 1D.

num_conv_pos_embedding_groups (`int`, *facultatif*, valeur par défaut 16) : Nombre de groupes de la couche d'embeddings positionnels de convolution 1D.

do_stable_layer_norm (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut appliquer l'architecture de normalisation de couche *stable* de l'encodeur Transformer. `do_stable_layer_norm is True` correspond à l'application de la normalisation de couche avant la couche d'attention, tandis que `do_stable_layer_norm is False` correspond à l'application de la normalisation de couche après la couche d'attention.

apply_spec_augment (`bool`, *facultatif*, valeur par défaut `True`) : 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](https://huggingface.co/papers/1904.08779).

mask_time_prob (`float`, *facultatif*, valeur par défaut 0.05) : Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe temporel qui seront masqués. La procédure de masquage génère ''mask_time_prob*len(time_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_time_prob* doit être `prob_vector_start*mask_time_length`. Notez que les chevauchements peuvent réduire le pourcentage réel de vecteurs masqués. Cela n'est pertinent que si `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) : Nombre minimal de masques de longueur `mask_feature_length` générés le long de l'axe temporel, à chaque pas de temps, 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`, *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 du vecteur à masquer, *mask_feature_prob* doit être `prob_vector_start*mask_feature_length`. Notez que les chevauchements peuvent réduire le pourcentage réel de vecteurs masqués. Cela n'est pertinent que si `apply_spec_augment is True`.

mask_feature_length (`int`, *facultatif*, 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 pas de temps, 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_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*, 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*, valeur par défaut `mean`) : Spécifie la réduction à appliquer à la sortie de `torch.nn.CTCLoss`. Ne concerne que l'entraînement.

ctc_zero_infinity (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut mettre à zéro les pertes infinies et les gradients associés de `torch.nn.CTCLoss`. Les pertes infinies surviennent 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 [UniSpeechSatForCTC](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

use_weighted_layer_sum (`bool`, *facultatif*, valeur par défaut `False`) : 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 [UniSpeechSatForSequenceClassification](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification).

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]` ou `list[int]`, *facultatif*, valeur par défaut `(512, 512, 512, 512, 1500)`) : Un tuple d'entiers définissant le nombre de canaux de sortie de chaque couche convolutive 1D du module *TDNN* du modèle *XVector*. La longueur de *tdnn_dim* définit le nombre de couches *TDNN*.

tdnn_kernel (`tuple[int]` ou `list[int]`, *facultatif*, valeur 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]` ou `list[int]`, *facultatif*, valeur 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*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`int`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

num_clusters (`int`, *facultatif*, valeur par défaut 504) : Nombre de clusters pour l'étiquetage faible. Ne concerne que l'utilisation d'une instance de [UniSpeechSatForPreTraining](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining).

Il s’agit de la classe de configuration destinée à stocker la configuration d’un modèle Unispeech SatModel. Elle est utilisée pour instancier un modèle Unispeech Sat en fonction des arguments spécifiés, en définissant l’architecture du modèle. L’instanciation d’une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/unispeech-sat-base-100h-libri-ft](https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import UniSpeechSatModel, UniSpeechSatConfig

>>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> configuration = UniSpeechSatConfig()

>>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> model = UniSpeechSatModel(configuration)

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

## Sorties spécifiques de UniSpeechSat[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

#### transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

```python
transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L66)

**Paramètres :**

loss (`*optional*`, returned when model is in train mode, `torch.Tensor` of 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](https://huggingface.co/papers/2006.11477).

logits (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`, *facultatif*) : Scores de prédiction du modèle de perte contrastive, c'est-à-dire la sortie du modèle avant le softmax final.

projected_states (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) : États cachés du modèle projetés sur *config.proj_codevector_dim* qui peuvent être utilisés pour prédire les états quantifiés projetés masqués.

projected_quantized_states (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) : Vecteurs de caractéristiques extraites quantifiés et projetés sur *config.proj_codevector_dim*, représentant les vecteurs cibles positifs pour la perte contrastive.

codevector_perplexity (`torch.Tensor` de forme `(1,)`) : La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook.

hidden_states (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d’embedding initiales facultatives.

attentions (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Type de sortie de `UniSpeechSatForPreTrainingOutput`, avec états cachés et attentions potentiels.

## UniSpeechSatModel[[transformers.UniSpeechSatModel]]

#### transformers.UniSpeechSatModel[[transformers.UniSpeechSatModel]]

```python
transformers.UniSpeechSatModel(config: UniSpeechSatConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L881)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Unispeech Sat brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatModel.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L944)

**Paramètres :**

input_values (`torch.Tensor` de 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 `.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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices pour masquer les fonctionnalités extraites pour 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](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) ou `tuple(torch.Tensor)`

Un [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et les entrées.

La méthode forward du modèle [UniSpeechSatModel](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatModel) redéfinit la méthode spéciale `__call__`.

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

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **extract_features** (`torch.Tensor` de 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.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é 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)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

#### transformers.UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

```python
transformers.UniSpeechSatForCTC(config: UniSpeechSatConfig, target_lang: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1096)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) avec des adaptateurs. Utilise 'eng' par défaut.

Modèle UniSpeechSat avec une tête de `language modeling` au sommet pour la Classification Temporelle Connectiviste (CTC).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatForCTC.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1165)

**Paramètres :**

input_values (`torch.Tensor` de 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 `.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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

labels (`torch.LongTensor` de forme `(batch_size, target_length)`, *facultatif*) : Étiquettes pour la classification temporelle connexionniste. Notez que `target_length` doit ê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 `-100` sont ignorées (masquées) ; la perte n'est calculée que pour les étiquettes comprises dans `[0, ..., config.vocab_size - 1]`.

**Retourne :** [CausalLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) ou `tuple(torch.Tensor)`

Un [CausalLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.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 ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et des entrées.

La méthode forward de [UniSpeechSatForCTC](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) 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 (pour la prédiction du jeton suivant).
- **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).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoProcessor, UniSpeechSatForCTC
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForCTC.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> # 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)
...
```

## UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

#### transformers.UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

```python
transformers.UniSpeechSatForSequenceClassification(config: UniSpeechSatConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1223)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle UniSpeechSat avec une tête de classification de séquences au sommet (une couche linéaire sur la sortie agrégée) pour des tâches telles que la détection de mots-clés SUPERB.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatForSequenceClassification.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1256)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. 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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir `UniSpeechSatProcessor.__call__` pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

labels (`torch.LongTensor` de 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]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

**Retourne :** [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Un [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et les entrées.

La méthode forward de [UniSpeechSatForSequenceClassification](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification) 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 classification (ou de régression si config.num_labels==1).
- **logits** (`torch.Tensor` de 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple de classification mono-étiquette :

```python
>>> import torch
>>> from transformers import AutoTokenizer, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> 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 = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Exemple de classification multi-étiquettes :

```python
>>> import torch
>>> from transformers import AutoTokenizer, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", 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 = UniSpeechSatForSequenceClassification.from_pretrained(
...     "microsoft/unispeech-sat-base-100h-libri-ft", 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).loss
```

## UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

#### transformers.UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

```python
transformers.UniSpeechSatForAudioFrameClassification(config: UniSpeechSatConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1316)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Unispeech Sat avec une tête de classification de trame au sommet pour des tâches telles que la diarisation des locuteurs.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatForAudioFrameClassification.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1348)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. 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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir `UniSpeechSatProcessor.__call__` pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

labels (`torch.LongTensor` de 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]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

**Retourne :** [TokenClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)`

Un [TokenClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et les entrées.

La méthode forward de [UniSpeechSatForAudioFrameClassification](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForAudioFrameClassification) 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 classification.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores de classification (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForAudioFrameClassification
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForAudioFrameClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> # 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()
...
```

## UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

#### transformers.UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

```python
transformers.UniSpeechSatForXVector(config: UniSpeechSatConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1464)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle UniSpeechSat avec une tête d'extraction de caractéristiques XVector au sommet pour des tâches telles que la vérification de locuteur.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatForXVector.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1514)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. 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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir `UniSpeechSatProcessor.__call__` pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

labels (`torch.LongTensor` de 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]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

**Retourne :** [XVectorOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.XVectorOutput) ou `tuple(torch.Tensor)`

Un [XVectorOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.XVectorOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et les entrées.

La méthode forward de [UniSpeechSatForXVector](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForXVector) 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 classification.
- **logits** (`torch.Tensor` de forme `(batch_size, config.xvector_output_dim)`) -- États cachés de classification avant AMSoftmax.
- **embeddings** (`torch.Tensor` de 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.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é 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)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForXVector
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForXVector.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> # 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)
...
```

## UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

#### transformers.UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

```python
transformers.UniSpeechSatForPreTraining(config: UniSpeechSatConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L990)

**Paramètres :**

config ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle UniSpeechSat avec un module de quantification vectorielle et une perte ctc pour la pré-formation.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.UniSpeechSatForPreTraining.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1046)

**Paramètres :**

input_values (`torch.Tensor` de 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 `.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 [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

**Retourne :** [UniSpeechSatForPreTrainingOutput](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) ou `tuple(torch.Tensor)`

Un [UniSpeechSatForPreTrainingOutput](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UniSpeechSatConfig](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) et les entrées.

La méthode forward de [UniSpeechSatForPreTraining](/docs/transformers/v5.23.0/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining) 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** (`*optional*`, returned when model is in train mode, `torch.Tensor` of 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](https://huggingface.co/papers/2006.11477).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`, *facultatif*) -- Scores de prédiction du modèle de perte contrastive, c'est-à-dire la sortie du modèle avant le softmax final.
- **projected_states** (`torch.Tensor` de 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.Tensor` de 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.Tensor` de forme `(1,)`) -- La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
>>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
>>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
>>> # TODO: Add full pretraining example
```

