# GraniteSpeech5

## Aperçu

Granite Speech 5.0 Turbo CTC est un encodeur conformer léger (~470M paramètres) pour la reconnaissance automatique de la parole, entraîné avec la Classification Temporelle Connectiviste (CTC) sur des cibles BPE. C'est un membre rapide, à encodeur uniquement, de la famille [Granite Speech](https://huggingface.co/papers/2505.08699) : la transcription nécessite un seul passage avant suivi d'un décodage CTC glouton, sans décodeur autorégressif.

Sur le plan architectural, il étend l'encodeur conformer CTC de Granite Speech avec :

1. **Empilement de trames + sous-échantillonnage temporel par blocs** : l'extracteur de caractéristiques empile des paires de trames log-mel(+delta) (2x), et les deux premiers blocs conformer sous-échantillonnent le temps par 2 via une convolution depthwise de pas 2 (avec un résidu moyenné), pour une réduction temporelle totale de 8x à 10 ms de pas mel.

2. **Attention par blocs avec les embeddings de position relative de Shaw** : l'attention est calculée sur des blocs de taille fixe (la séquence est complétée à droite jusqu'à un nombre entier de blocs, les cadres complétés étant masqués), en utilisant des projections distinctes sans biais pour les requêtes/clés/valeurs.

3. **CTC auto-conditionné** : les postérieurs CTC de la couche intermédiaire sont projetés et réinjectés dans les états cachés, et la tête CTC est partagée entre cet auto-conditionnement de la couche intermédiaire et la prédiction finale.

Ce modèle a été contribué par [Eustache Le Bihan](https://huggingface.co/eustlb).

## Utilisation

### Utilisation de `GraniteSpeech5ForCTC`

```python
from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="ibm-granite/granite-speech-5.0-470m-turboctc")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was 35 degrees in barcelona but today the temperature will go down to -20 degrees'}
```

```python
from datasets import Audio, load_dataset
from transformers import AutoModelForCTC, AutoProcessor

model_id = "ibm-granite/granite-speech-5.0-470m-turboctc"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCTC.from_pretrained(model_id, device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el['array'] for el in ds["audio"][:5]]

# `device` computes the log-mel front-end on the model's accelerator, saving a host-to-device copy
inputs = processor(
    speech_samples, sampling_rate=processor.feature_extractor.sampling_rate, device=model.device
)
inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs)
print(processor.batch_decode(outputs, skip_special_tokens=True))
# ['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel', ...]
```

## GraniteSpeech5CTCConfig[[transformers.GraniteSpeech5CTCConfig]]

#### transformers.GraniteSpeech5CTCConfig[[transformers.GraniteSpeech5CTCConfig]]

```python
transformers.GraniteSpeech5CTCConfig(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 = 16384, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = True, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int | None = 0, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/configuration_granite_speech5.py#L97)

**Paramètres :**

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

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 d'une instance de [GraniteSpeech5ForCTC](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5ForCTC).

ctc_zero_infinity (`bool`, *facultatif*, valeur par défaut `True`) : 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 [GraniteSpeech5ForCTC](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5ForCTC).

encoder_config (`Union[dict, GraniteSpeech5EncoderConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire de l'encodeur.

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

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 Granite Speech5Model. Elle est utilisée pour instancier un modèle Granite Speech5 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 [ibm-granite/granite-speech-5.0-470m-turboctc](https://huggingface.co/ibm-granite/granite-speech-5.0-470m-turboctc)

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 GraniteSpeech5ForCTC, GraniteSpeech5CTCConfig
>>> # Initializing a GraniteSpeech5 configuration
>>> configuration = GraniteSpeech5CTCConfig()
>>> # Initializing a model from the configuration
>>> model = GraniteSpeech5ForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## GraniteSpeech5EncoderConfig[[transformers.GraniteSpeech5EncoderConfig]]

#### transformers.GraniteSpeech5EncoderConfig[[transformers.GraniteSpeech5EncoderConfig]]

```python
transformers.GraniteSpeech5EncoderConfig(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 = 16384, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 16, num_attention_heads: int = 8, num_key_value_heads: int | None = None, num_mel_bins: int = 80, head_dim: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 512, context_size: int = 128, conv_kernel_size: int = 7, conv_expansion_factor: int = 2, subsample_layers: list[int] | None = None, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_range: float = 0.02)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/configuration_granite_speech5.py#L29)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `16384`) : 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*, valeur par défaut `1024`) : Dimension des représentations cachées.

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

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

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

num_key_value_heads (`int`, *facultatif*) : C'est le nombre de têtes de key_value à utiliser pour implémenter l'attention par requêtes groupées (Grouped Query Attention). Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention multi-têtes (Multi Head Attention, MHA) ; si `num_key_value_heads=1`, il utilisera l'attention multi-requête (Multi Query Attention, MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête de clé et de valeur du groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.

num_mel_bins (`int`, *facultatif*, valeur par défaut `80`) : Nombre de caractéristiques mel utilisées par trame d'entrée. Doit correspondre à la valeur utilisée dans la classe `AutoFeatureExtractor`.

head_dim (`int`, *facultatif*) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads

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

max_position_embeddings (`int`, *facultatif*, valeur par défaut : 512) : Index maximal de position relative pour l'encodage positionnel relatif de Shaw ; la table d'incorporation contient `2 * max_position_embeddings + 1` entrées.

context_size (`int`, *facultatif*, valeur par défaut 128) : Taille du contexte pour l'attention conformer par blocs.

conv_kernel_size (`int`, *facultatif*, valeur par défaut : 7) : Taille du noyau de la convolution en profondeur dans le module de convolution du conformer.

conv_expansion_factor (`int`, *facultatif*, valeur par défaut : 2) : Facteur d'expansion pour le module de convolution conformer.

subsample_layers (`list[int]`, *facultatif*, valeur par défaut `[0, 1]`) : Indices des blocs conformer qui sous-échantillonnent le temps par 2 (convolution depthwise de pas 2 avec un résidu moyenné).

attention_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention.

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.

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.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un Granite Speech5Model. Elle est utilisée pour instancier un modèle Granite Speech5 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 [ibm-granite/granite-speech-5.0-470m-turboctc](https://huggingface.co/ibm-granite/granite-speech-5.0-470m-turboctc)

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 GraniteSpeech5EncoderConfig, GraniteSpeech5Encoder

>>> # Initializing a GraniteSpeech5EncoderConfig
>>> configuration = GraniteSpeech5EncoderConfig()

>>> # Initializing a GraniteSpeech5Encoder (with random weights)
>>> model = GraniteSpeech5Encoder(configuration)

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

## GraniteSpeech5FeatureExtractor[[transformers.GraniteSpeech5FeatureExtractor]]

#### transformers.GraniteSpeech5FeatureExtractor[[transformers.GraniteSpeech5FeatureExtractor]]

```python
transformers.GraniteSpeech5FeatureExtractor(num_mel_bins: int = 80, sampling_rate: int = 16000, n_fft: int = 512, win_length: int = 400, hop_length: int = 160, delta_win_length: int = 3, logmel_floor_db: float = 8.0, padding_value: float = 0.0, **kwargs)
```

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

**Paramètres :**

num_mel_bins (`int`, *facultatif*, valeur par défaut : 80) : Nombre de banques de filtres mel.

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

n_fft (`int`, *facultatif*, valeur par défaut 512) : Taille de la transformée de Fourier.

win_length (`int`, *facultatif*, valeur par défaut : 400) : Longueur de la fenêtre en échantillons.

hop_length (`int`, *facultatif*, valeur par défaut 160) : Longueur des fenêtres superposées pour la STFT utilisée pour obtenir le spectrogramme mel, en échantillons.

delta_win_length (`int`, *facultatif*, valeur par défaut : 3) : Longueur de la fenêtre utilisée pour calculer les caractéristiques delta.

logmel_floor_db (`float`, *facultatif*, valeur par défaut 8.0) : Les caractéristiques log-mel sont plafonnées à ce nombre de dB en dessous du maximum par échantillon.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : Valeur de bourrage utilisée pour bourrer l'audio.

Construit un extracteur de fonctionnalités Granite Speech 5.0.

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

## GraniteSpeech5Processor[[transformers.GraniteSpeech5Processor]]

#### transformers.GraniteSpeech5Processor[[transformers.GraniteSpeech5Processor]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/processing_granite_speech5.py#L26)

**Paramètres :**

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

tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire.

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

[GraniteSpeech5Processor](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5Processor) offre toutes les fonctionnalités de `feature_extractor_class` et de `tokenizer_class`. Consultez `~feature_extractor_class` et `~tokenizer_class` pour plus d’informations.

## GraniteSpeech5Encoder[[transformers.GraniteSpeech5Encoder]]

#### transformers.GraniteSpeech5Encoder[[transformers.GraniteSpeech5Encoder]]

```python
transformers.GraniteSpeech5Encoder(config: GraniteSpeech5EncoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/modeling_granite_speech5.py#L368)

**Paramètres :**

config ([GraniteSpeech5EncoderConfig](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5EncoderConfig)) : 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.

L'encodeur conformer de Granite Speech 5.0, adapté de l'[encodeur CTC de Granite Speech](https://huggingface.co/papers/2505.08699) avec sous-échantillonnage temporel par blocs et CTC auto-conditionné à partir de la couche intermédiaire.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/modeling_granite_speech5.py#L395)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de `feature_extractor_class`. Voir `feature_extractor_class.__call__` pour plus de détails (`processor_class` utilise `feature_extractor_class` 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)

output_attention_mask (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner le masque d'attention de sortie. N'est efficace que si `attention_mask` est fourni.

**Retourne :** `GraniteSpeech5EncoderModelOutput` ou `tuple(torch.Tensor)`

Un `GraniteSpeech5EncoderModelOutput` 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 (`None`) et les entrées.

La méthode forward de [GraniteSpeech5Encoder](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5Encoder) 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.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **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.
- **attention_mask** (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) -- Masque permettant d'éviter d'appliquer l'attention aux indices des jetons de bourrage après la compression de la séquence. Renvoyé car la longueur de la séquence peut différer de la longueur de la séquence d'entrée. Valeurs du masque comprises dans `[0, 1]` :

  - 1 pour les jetons qui ne sont **pas masqués**,
  - 0 pour les jetons **masqués**.

Exemple :

```python
>>> from transformers import AutoProcessor, GraniteSpeech5Encoder
>>> from datasets import load_dataset, Audio

>>> model_id = "ibm-granite/granite-speech-5.0-470m-turboctc"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = GraniteSpeech5Encoder.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)
```

## GraniteSpeech5ForCTC[[transformers.GraniteSpeech5ForCTC]]

#### transformers.GraniteSpeech5ForCTC[[transformers.GraniteSpeech5ForCTC]]

```python
transformers.GraniteSpeech5ForCTC(config: GraniteSpeech5CTCConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/modeling_granite_speech5.py#L496)

**Paramètres :**

config ([GraniteSpeech5CTCConfig](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5CTCConfig)) : 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.

Encodeur Granite Speech 5.0 avec une tête de 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.GraniteSpeech5ForCTC.forward]]

```python
forward(input_features: 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/granite_speech5/modeling_granite_speech5.py#L511)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de `feature_extractor_class`. Voir `feature_extractor_class.__call__` pour plus de détails (`processor_class` utilise `feature_extractor_class` 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)

labels (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être 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 dans `[0, ..., config.vocab_size]`.

**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 selon la configuration (`None`) et les entrées.

La méthode forward de [GraniteSpeech5ForCTC](/docs/transformers/v5.23.0/fr/model_doc/granite_speech5#transformers.GraniteSpeech5ForCTC) 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, GraniteSpeech5ForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/granite_speech5-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = GraniteSpeech5ForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
>>> outputs = model(**inputs)

>>> print(outputs.loss)
```

#### generate[[transformers.GraniteSpeech5ForCTC.generate]]

```python
generate(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, return_dict_in_generate: bool = False, compile_config: transformers.generation.configuration_utils.CompileConfig | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/granite_speech5/modeling_granite_speech5.py#L571)

compile_config ([CompileConfig](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.CompileConfig), *facultatif*) : s'il est fourni, `torch.compile` sera appliqué aux appels forward dans la boucle de décodage.

Exemple :

```python
>>> from transformers import AutoProcessor, GraniteSpeech5ForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "ibm-granite/granite-speech-5.0-470m-turboctc"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = GraniteSpeech5ForCTC.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> predicted_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> print(transcription)
```

