# Speech2Text

## Aperçu

Le modèle Speech2Text a été proposé dans [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://huggingface.co/papers/2010.05171) par Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino. C'est un modèle seq2seq (encodeur-décodeur) basé sur un transformer, conçu pour la Reconnaissance Automatique de la Parole (ASR) et la Traduction de la Parole (ST) de bout en bout. Il utilise un sous-échantillonneur convolutif pour réduire la longueur des entrées vocales de 3/4 avant qu'elles ne soient transmises à l'encodeur. Le modèle est entraîné avec une perte d'entropie croisée autorégressive standard et génère les transcriptions/traductions de manière autorégressive. Speech2Text a été affiné sur plusieurs jeux de données pour l'ASR et la ST : [LibriSpeech](http://www.openslr.org/12), [CoVoST 2](https://github.com/facebookresearch/covost), [MuST-C](https://ict.fbk.eu/must-c/).

Ce modèle a été contribué par [valhalla](https://huggingface.co/valhalla). Le code d'origine est disponible [ici](https://github.com/pytorch/fairseq/tree/master/examples/speech_to_text).

## Inférence

Speech2Text est un modèle de parole qui accepte un tenseur de flottants représentant les caractéristiques log-mel filter-bank extraites du signal de parole. C'est un modèle seq2seq basé sur un transformer, de sorte que les transcriptions/traductions sont générées de manière autorégressive. La méthode `generate()` peut être utilisée pour l'inférence.

La classe [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) est chargée d’extraire les caractéristiques de la banque de filtres log-mel. Le [Speech2TextProcessor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextProcessor) encapsule [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) et [Speech2TextTokenizer](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextTokenizer) en une seule instance afin d’extraire les caractéristiques d’entrée et de décoder les identifiants de jetons prédits.

L’extracteur de caractéristiques dépend de `torchaudio` et le tokeniseur dépend de `sentencepiece` ; assurez-vous donc d’installer ces paquets avant d’exécuter les exemples. Vous pouvez soit les installer en tant que dépendances supplémentaires pour la parole avec `pip install transformers"[speech, sentencepiece]"`, soit installer les paquets séparément avec `pip install torchaudio sentencepiece`. De plus, `torchaudio` nécessite la version de développement du paquet [libsndfile](http://www.mega-nerd.com/libsndfile/), qui peut être installé via un gestionnaire de paquets système. Sur Ubuntu, il peut être installé comme suit : `apt install libsndfile1-dev`

- ASR et traduction vocale

```python
from datasets import load_dataset

from transformers import Speech2TextForConditionalGeneration, Speech2TextProcessor

model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr", device_map="auto")
processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt").to(model.device)
generated_ids = model.generate(inputs["input_features"], attention_mask=inputs["attention_mask"])

transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
transcription
['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']
```

- Traduction vocale multilingue

  Pour les modèles de traduction vocale multilingue, `eos_token_id` est utilisé comme `decoder_start_token_id` et l'identifiant de la langue cible est forcé comme premier jeton généré. Pour forcer l'identifiant de la langue cible comme premier jeton généré, passez le paramètre `forced_bos_token_id` à la méthode `generate()`. L'exemple suivant montre comment traduire un discours en anglais en texte français à l'aide du point de contrôle *facebook/s2t-medium-mustc-multilingual-st*.

```python
from datasets import load_dataset

from transformers import Speech2TextForConditionalGeneration, Speech2TextProcessor

model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-medium-mustc-multilingual-st", device_map="auto")
processor = Speech2TextProcessor.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")

ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt").to(model.device)
generated_ids = model.generate(
    inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    forced_bos_token_id=processor.tokenizer.lang_code_to_id["fr"],
)

translation = processor.batch_decode(generated_ids, skip_special_tokens=True)
translation
["(Vidéo) Si M. Kilder est l'apossible des classes moyennes, et nous sommes heureux d'être accueillis dans son évangile."]
```

Consultez le [model hub](https://huggingface.co/models?filter=speech_to_text) pour rechercher des points de contrôle Speech2Text.

## Speech2TextConfig[[transformers.Speech2TextConfig]]

#### transformers.Speech2TextConfig[[transformers.Speech2TextConfig]]

```python
transformers.Speech2TextConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 10000, encoder_layers: int = 12, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 4, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 4, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, decoder_start_token_id: int = 2, scale_embedding: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_source_positions: int = 6000, max_target_positions: int = 1024, num_conv_layers: int = 2, conv_kernel_sizes: list[int] | tuple[int, ...] = (5, 5), conv_channels: int = 1024, input_feat_per_channel: int = 80, input_channels: int = 1, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/configuration_speech_to_text.py#L24)

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

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

encoder_layers (`int`, *facultatif*, valeur par défaut `12`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

encoder_ffn_dim (`int`, *facultatif*, valeur par défaut `2048`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

encoder_attention_heads (`int`, *facultatif*, valeur par défaut `4`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

decoder_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

decoder_ffn_dim (`int`, *facultatif*, valeur par défaut `2048`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.

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

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

decoder_layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Probabilité de LayerDrop pour le décodeur. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

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

d_model (`int`, *facultatif*, par défaut `256`) : Taille des couches d'encodeur et de la couche pooler.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

init_std (`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.

decoder_start_token_id (`int`, *facultatif*, valeur par défaut `2`) : si un modèle encodeur-décodeur commence le décodage avec un jeton différent de `bos`, l'identifiant de ce jeton.

scale_embedding (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).

pad_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

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

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

max_source_positions (`int`, *facultatif*, valeur par défaut 6000) : La longueur de séquence maximale des caractéristiques de filtres log-mel avec laquelle ce modèle pourrait être utilisé.

max_target_positions (`int`, *facultatif*, valeur par défaut 1024) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).

num_conv_layers (`int`, *facultatif*, valeur par défaut : 2) : Nombre de couches de convolution 1D dans le module conv.

conv_kernel_sizes (`tuple[int]`, *facultatif*, valeur par défaut `(5, 5)`) : Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du module conv. La longueur de `conv_kernel_sizes` doit correspondre à `num_conv_layers`.

conv_channels (`int`, *facultatif*, valeur par défaut 1024) : Un entier définissant le nombre de canaux de sortie de chaque couche de convolution, à l'exception de la dernière, dans le module conv.

input_feat_per_channel (`int`, *facultatif*, valeur par défaut : 80) : Un entier spécifiant la taille du vecteur de caractéristiques. Il correspond également aux dimensions des caractéristiques de la banque de filtres log-mel.

input_channels (`int`, *facultatif*, par défaut `1`) : Le nombre de canaux d'entrée.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Speech2TextModel. Elle est utilisée pour instancier un modèle Speech To Text 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 [facebook/s2t-small-librispeech-asr](https://huggingface.co/facebook/s2t-small-librispeech-asr)

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 Speech2TextConfig, Speech2TextModel

>>> # Initializing a Speech2Text s2t_transformer_s style configuration
>>> configuration = Speech2TextConfig()

>>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
>>> model = Speech2TextModel(configuration)

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

## Speech2TextTokenizer[[transformers.Speech2TextTokenizer]]

#### transformers.Speech2TextTokenizer[[transformers.Speech2TextTokenizer]]

```python
transformers.Speech2TextTokenizer(vocab_file, spm_file, bos_token = '<s>', eos_token = '</s>', pad_token = '<pad>', unk_token = '<unk>', do_upper_case = False, do_lower_case = False, tgt_lang = None, lang_codes = None, additional_special_tokens = None, sp_model_kwargs: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L49)

**Paramètres :**

vocab_file (`str`) : Fichier contenant le vocabulaire.

spm_file (`str`) : Chemin vers le fichier de modèle [SentencePiece](https://github.com/google/sentencepiece)

bos_token (`str`, *facultatif*, par défaut `"<s>"`) : Jeton de début de phrase.

eos_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : Jeton de fin de phrase.

unk_token (`str`, *facultatif*, par défaut `"<unk>"`) : Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

pad_token (`str`, *facultatif*, par défaut `"<pad>"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

do_upper_case (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut mettre la sortie en majuscules lors du décodage.

do_lower_case (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation.

tgt_lang (`str`, *facultatif*) : Une chaîne de caractères représentant la langue cible.

sp_model_kwargs (`dict`, *facultatif*) : Sera transmis à la méthode `SentencePieceProcessor.__init__()`. Le [Python wrapper for SentencePiece](https://github.com/google/sentencepiece/tree/master/python) peut notamment être utilisé pour définir :  - `enable_sampling` : Active la régularisation des sous-mots. - `nbest_size` : Paramètres d'échantillonnage pour unigramme. Invalide pour BPE-Dropout.  - `nbest_size = {0,1}` : Aucun échantillonnage n'est effectué. - `nbest_size > 1` : échantillonne à partir des résultats nbest_size. - `nbest_size < 0` : suppose que nbest_size est infini et échantillonne à partir de toutes les hypothèses (lattice) en utilisant l'algorithme forward-filtering-and-backward-sampling.  - `alpha` : Paramètre de lissage pour l'échantillonnage unigramme, et probabilité de dropout des opérations de fusion pour BPE-dropout.

- ****kwargs** : Arguments supplémentaires passés à [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend)

Construisez un tokenizer Speech2Text.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient certaines des principales méthodes. Les utilisateurs doivent se reporter à la classe parente pour plus d’informations sur ces méthodes.

#### build_inputs_with_special_tokens[[transformers.Speech2TextTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0, token_ids_1 = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L206)

Construire les entrées du modèle à partir d'une séquence en ajoutant eos_token_id.

#### get_special_tokens_mask[[transformers.Speech2TextTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L213)

**Paramètres :**

token_ids_0 (`list[int]`) : Liste d'identifiants.

token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences.

already_has_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.

**Retourne :** `list[int]`

Une liste d'entiers dans l'intervalle [0, 1] : 1 pour un jeton spécial, 0 pour un jeton de séquence.

Récupère les identifiants de séquences à partir d'une liste de jetons sur laquelle aucun jeton spécial n'a été ajouté. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide de la méthode `prepare_for_model` du tokeniseur.

#### create_token_type_ids_from_sequences[[transformers.Speech2TextTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301)

**Paramètres :**

token_ids_0 (`list[int]`) : Liste d'identifiants.

token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences.

**Retourne :** `list[int]`

Identifiants de type de jeton selon le motif configuré.

Créez un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences.

Cette méthode construit dynamiquement les identifiants de type de jeton en fonction des attributs de configuration du tokeniseur :
- `token_type_ids_pattern` : Motif à utiliser (« all_zeros » ou « bert_style »)
- `token_type_ids_include_special_tokens` : Indique s'il faut prendre en compte les jetons spéciaux dans le calcul de la longueur

Exemples :
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.Speech2TextTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L257)

## Speech2TextFeatureExtractor[[transformers.Speech2TextFeatureExtractor]]

#### transformers.Speech2TextFeatureExtractor[[transformers.Speech2TextFeatureExtractor]]

```python
transformers.Speech2TextFeatureExtractor(feature_size = 80, sampling_rate = 16000, num_mel_bins = 80, padding_value = 0.0, dither = 0.0, do_ceptral_normalize = True, normalize_means = True, normalize_vars = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/feature_extraction_speech_to_text.py#L33)

**Paramètres :**

feature_size (`int`, *facultatif*, valeur par défaut 80) : La dimension des caractéristiques des fonctionnalités extraites.

sampling_rate (`int`, *facultatif*, valeur par défaut 16000) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

num_mel_bins (`int`, *facultatif*, valeur par défaut 80) : Nombre de bandes de fréquences Mel.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : La valeur utilisée pour remplir les vecteurs de bourrage.

dither (`float`, *facultatif*, valeur par défaut 0.0) : Ajoute un dithering. Autrement dit, ajoute un petit bruit gaussien à chaque image. Par exemple, utilisez 4.0 pour ajouter un dithering avec une distribution normale centrée sur 0.0 et un écart-type de 4.0 (en supposant une plage de [-32k, +32k] pour la forme d'onde kaldi). La valeur 0.0 signifie qu'aucun dithering n'est appliqué. Le dithering a un effet similaire à celui de `mel_floor`. Il réduit les valeurs élevées de log_mel_fbank pour les signaux comportant des sections à zéro dur, lorsque la coupure VAD est présente dans le signal.

do_ceptral_normalize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut appliquer la normalisation du moyen et de la variance cepstrale au niveau de l'énoncé aux extraits de caractéristiques.

normalize_means (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser les caractéristiques extraites par soustraction de la moyenne.

normalize_vars (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser les caractéristiques extraites avec une variance unitaire.

Construit un extracteur de fonctionnalités Speech2Text.

Cet extracteur de fonctionnalités hérite de [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait les caractéristiques de la banque de filtres mel à partir du signal vocal brut en utilisant TorchAudio s'il est installé, ou numpy sinon, et applique une normalisation du moyen et de la variance cepstrale au niveau de l'énoncé aux caractéristiques extraites.

#### __appel__[[transformers.Speech2TextFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = False, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, return_attention_mask: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/feature_extraction_speech_to_text.py#L174)

**Paramètres :**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Doit être un audio mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` : Padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

truncation (`bool`) : Active la troncature pour couper les séquences d'entrée plus longues que *max_length* à *max_length*.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient de longueurs de séquence multiples de 128.

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. S'il est laissé à sa valeur par défaut, le masque d'attention sera retourné selon la valeur par défaut du feature_extractor spécifique.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)    Pour les modèles Speech2TextTransformer, `attention_mask` doit toujours être transmis lors d'une inférence par lots, afin d'éviter des bugs subtils.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

sampling_rate (`int`, *facultatif*) : Le taux d'échantillonnage auquel l'entrée `raw_speech` a été échantillonnée. Il est fortement recommandé de passer `sampling_rate` lors de l'appel forward afin d'éviter les erreurs silencieuses.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : La valeur utilisée pour remplir les valeurs / vecteurs de bourrage.

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

## Speech2TextProcessor[[transformers.Speech2TextProcessor]]

#### transformers.Speech2TextProcessor[[transformers.Speech2TextProcessor]]

```python
transformers.Speech2TextProcessor(feature_extractor, tokenizer)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/processing_speech_to_text.py#L23)

**Paramètres :**

feature_extractor (`Speech2TextFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`Speech2TextTokenizer`) : le tokenizer est une entrée obligatoire.

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

[Speech2TextProcessor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextProcessor) offre toutes les fonctionnalités de [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) et de [Speech2TextTokenizer](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextTokenizer). Consultez [~Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) et [~Speech2TextTokenizer](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextTokenizer) pour plus d’informations.

#### __appel__[[transformers.Speech2TextProcessor.__call__]]

```python
__call__(*args, **kwargs)
```

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

**Paramètres :**

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

#### from_pretrained[[transformers.Speech2TextProcessor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1799)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Peut être soit : - une chaîne de caractères, l'*identifiant du modèle* d'un feature_extractor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co. - un chemin vers un *dossier* contenant un fichier de feature extractor enregistré à l'aide de la méthode [save_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), par exemple `./my_model_directory/`. - un chemin vers un fichier JSON *fichier* de feature extractor enregistré, par exemple `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Arguments supplémentaires passés à la fois à [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) et à `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

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

Cette méthode de classe appelle simplement la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) de l'extracteur de caractéristiques, le processeur d'images [ImageProcessingMixin](/docs/transformers/v5.23.0/fr/internal/image_processing_utils#transformers.ImageProcessingMixin) et la méthode `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` du tokeniseur. Veuillez consulter les docstrings des méthodes ci-dessus pour plus d'informations.

#### save_pretrained[[transformers.Speech2TextProcessor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1182)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : répertoire où le fichier JSON de l'extracteur de caractéristiques et les fichiers du tokenizer seront enregistrés (le répertoire sera créé s'il n'existe pas).

push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Enregistre les attributs de ce processeur (extracteur de caractéristiques, tokeniseur...) dans le répertoire spécifié afin qu'il puisse être rechargé à l'aide de la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Cette méthode de classe appelle simplement [save_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) et [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Veuillez consulter les docstrings des méthodes ci-dessus pour plus d’informations.

#### batch_decode[[transformers.Speech2TextProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2054)

Cette méthode transmet tous ses arguments à [batch_decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

#### decode[[transformers.Speech2TextProcessor.decode]]

```python
decode(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2063)

Cette méthode transmet tous ses arguments à [decode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

## Speech2TextModel[[transformers.Speech2TextModel]]

#### transformers.Speech2TextModel[[transformers.Speech2TextModel]]

```python
transformers.Speech2TextModel(config: Speech2TextConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L720)

**Paramètres :**

config ([Speech2TextConfig](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextConfig)) : 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 Speech To Text Text 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.Speech2TextModel.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L736)

**Paramètres :**

input_features (`torch.LongTensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor). Voir [Speech2TextFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor.__call__) pour plus de détails ([Speech2TextProcessor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextProcessor) utilise [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) pour le traitement des audios).

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)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de `SpeechToTextTokenizer`. Voir [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Quelles sont les IDs d'entrée du décodeur ?](../glossary#decoder-input-ids) SpeechToText utilise `eos_token_id` comme jeton de départ pour la génération de `decoder_input_ids`. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_input_ids` (voir `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire `modeling_speech_to_text._prepare_decoder_attention_mask` et l'adapter à vos besoins. Consultez la figure 1 de [l'article](https://huggingface.co/papers/1910.13461) pour plus d'informations sur la stratégie par défaut.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *facultatif*) : le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

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

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([Speech2TextConfig](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextConfig)) et des entrées.

La méthode forward de [Speech2TextModel](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextModel) redéfinit la méthode spéciale `__call__`.

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

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> import torch
>>> from transformers import Speech2TextModel, AutoFeatureExtractor
>>> from datasets import load_dataset

>>> model = Speech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 256]
```

## Speech2TextForConditionalGeneration[[transformers.Speech2TextForConditionalGeneration]]

#### transformers.Speech2TextForConditionalGeneration[[transformers.Speech2TextForConditionalGeneration]]

```python
transformers.Speech2TextForConditionalGeneration(config: Speech2TextConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L842)

**Paramètres :**

config ([Speech2TextConfig](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextConfig)) : 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 Speech2Text avec une tête de modélisation de langage. Peut être utilisé pour la résumation.

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.Speech2TextForConditionalGeneration.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L855)

**Paramètres :**

input_features (`torch.LongTensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor). Voir [Speech2TextFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor.__call__) pour plus de détails ([Speech2TextProcessor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextProcessor) utilise [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) pour le traitement des audios).

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)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de `SpeechToTextTokenizer`. Voir [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Quelles sont les IDs d'entrée du décodeur ?](../glossary#decoder-input-ids) SpeechToText utilise `eos_token_id` comme jeton de départ pour la génération de `decoder_input_ids`. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_input_ids` (voir `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire `modeling_speech_to_text._prepare_decoder_attention_mask` et l'adapter à vos besoins. Consultez la figure 1 de [l'article](https://huggingface.co/papers/1910.13461) pour plus d'informations sur la stratégie par défaut.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *facultatif*) : le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation du langage. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

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

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([Speech2TextConfig](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextConfig)) et des entrées.

La méthode forward de [Speech2TextForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/speech_to_text#transformers.Speech2TextForConditionalGeneration) redéfinit la méthode spéciale `__call__`.

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

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset

>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
```

