# Nemotron ASR Streaming

## Aperçu

Nemotron ASR Streaming est un modèle de reconnaissance vocale en anglais de 600 millions de paramètres développé par NVIDIA, conçu pour une transcription de haute qualité dans des configurations à faible latence en streaming et à haut débit par lots, avec une ponctuation et une majuscule natives. Pour le streaming, il propose des tailles de blocs configurables—80 ms, 160 ms, 560 ms et 1120 ms—permettant aux utilisateurs d'ajuster le compromis entre latence et précision selon leur application. Son architecture FastConformer-RNNT sensible au cache est au cœur de cette capacité : contrairement au streaming par tampon traditionnel, qui re-traite de manière répétée des fenêtres audio superposées, le modèle ne traite que chaque nouveau bloc entrant tout en réutilisant le contexte encodeur mis en cache des blocs précédents. Cela élimine les calculs redondants, améliore considérablement l'efficacité et minimise la latence de bout en bout sans sacrifier la précision, ce qui le rend particulièrement adapté aux charges de travail de transcription en temps réel.

## Utilisation

### Transcription hors ligne

```python
from transformers import pipeline

pipe = pipeline(
    "automatic-speech-recognition",
    model="nvidia/nemotron-speech-streaming-en-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
```

```python
from transformers import AutoModelForRNNT, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
    sampling_rate=processor.feature_extractor.sampling_rate,
)

inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

### Transcription en streaming
> [!NOTE]
> Il s'agit d'une fonctionnalité expérimentale et l'API est susceptible d'évoluer.

Pour la transcription en temps réel, l’audio est découpé en segments selon :

```python
from threading import Thread
from transformers import AutoModelForRNNT, AutoProcessor, TextIteratorStreamer
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

processor.set_num_lookahead_tokens(6)
print(f"Streaming latency: {processor.streaming_latency_ms} ms")

sampling_rate = processor.feature_extractor.sampling_rate
audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/obama.mp3",
    sampling_rate=sampling_rate,
)

first_chunk_inputs = processor(
    audio[: processor.num_samples_first_audio_chunk],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=True,
    return_tensors="pt",
)
first_chunk_inputs = first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features[:, : processor.num_mel_frames_first_audio_chunk, :]

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    n_fft = processor.feature_extractor.n_fft

    start_idx = mel_frame_idx * hop_length - n_fft // 2
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
            return_tensors="pt",
        )
        inputs = inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.num_mel_frames_per_audio_chunk
        start_idx = mel_frame_idx * hop_length - n_fft // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True)
generate_kwargs = {
    **first_chunk_inputs,
    "input_features": input_features_generator(),
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)
thread.join()
```

#### Latence de streaming

La latence est définie par `num_lookahead_tokens`, le contexte d’attention adéquat (lookahead, dans les trames d’encodeur sous-échantillonnées) que chaque bloc attend avant d’être émis. Une valeur plus élevée permet à chaque bloc de voir plus d’audio futur : meilleure précision au prix d’une latence plus élevée. Inspectez les compromis pris en charge, sélectionnez-en un, puis lisez la latence résultante :

```python
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-speech-streaming-en-0.6b")

# Each supported `num_lookahead_tokens` mapped to its streaming latency in milliseconds:
print(processor.supported_streaming_latencies_ms)
# {13: 1120, 6: 560, 1: 160, 0: 80}

# Select a right attention context (this also re-derives the streaming chunk sizes used above):
processor.set_num_lookahead_tokens(6)

# Latency of the current selection:
print(processor.streaming_latency_ms)
# 560
```

`set_num_lookahead_tokens` détermine la taille des blocs émis par le processeur, et le `num_lookahead_tokens` correspondant doit parvenir à `generate` (dans l’exemple ci-dessus, il transite par `**inputs`/`**first_chunk_inputs`, qui transporte `num_lookahead_tokens`). Le `generate` en streaming lève une erreur s’il est omis.

## NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

#### transformers.NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

```python
transformers.NemotronAsrStreamingConfig(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 = 1025, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0, blank_token_id: int = 1024)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L119)

**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 `1025`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

decoder_hidden_size (`int`, *facultatif*, valeur par défaut : 640) : Taille cachée du réseau de prédiction LSTM (`pred_hidden` de NeMo). Le réseau conjoint projette les sorties de l'encodeur et du décodeur vers cette taille (`joint_hidden` de NeMo, que tous les points de contrôle connus définissent comme égale à `pred_hidden`).

num_decoder_layers (`int`, *facultatif*, valeur par défaut : 2) : Nombre de couches LSTM dans le réseau de prédiction.

hidden_act (`str`, *facultatif*, par défaut `"relu"`) : Activation dans le réseau conjoint.

max_symbols_per_step (`int`, *facultatif*, valeur par défaut 10) : Nombre maximal de symboles non vides émis par pas de temps de l'encodeur lors du décodage glouton.

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *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.

blank_token_id (`int`, *facultatif*, valeur par défaut 1024) : Identifiant du jeton vide. Différent de `pad_token_id` pour RNN-T.

Ceci est la classe de configuration destinée à stocker la configuration d'un NemotronAsrStreamingForRNNT. Elle est utilisée pour instancier un modèle Nemotron Asr Streaming 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 [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :
```python
>>> from transformers import NemotronAsrStreamingForRNNT, NemotronAsrStreamingConfig

>>> # Initializing a NemotronAsrStreaming RNN-T configuration
>>> configuration = NemotronAsrStreamingConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingForRNNT(configuration)

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

## NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

#### transformers.NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

```python
transformers.NemotronAsrStreamingEncoderConfig(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, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02, sliding_window: int = 71, default_num_lookahead_tokens: int = 13)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**Paramètres :**

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

num_hidden_layers (`int`, *facultatif*, valeur par défaut `24`) : 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.

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

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.

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.

convolution_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les convolutions du module de convolution du conformer.

conv_kernel_size (`int`, *facultatif*, valeur par défaut : 9) : La taille du noyau des couches de convolution dans le bloc Conformer.

subsampling_factor (`int`, *facultatif*, valeur par défaut : 8) : Le facteur par lequel la séquence d'entrée est sous-échantillonnée.

subsampling_conv_channels (`int`, *facultatif*, valeur par défaut : 256) : Le nombre de canaux dans les couches de convolution de sous-échantillonnage.

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

subsampling_conv_kernel_size (`int`, *facultatif*, valeur par défaut : 3) : La taille du noyau des couches de convolution de sous-échantillonnage.

subsampling_conv_stride (`int`, *facultatif*, par défaut 2) : Le pas des couches de convolution de sous-échantillonnage.

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

dropout_positions (`float`, *facultatif*, valeur par défaut 0.0) : Le taux de dropout pour les positions de la séquence d'entrée.

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.

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.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `5000`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

scale_input (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut mettre à l'échelle les embeddings d'entré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.

sliding_window (`int`, *facultatif*, valeur par défaut : 71) : Taille de la fenêtre glissante d'attention K/V (en trames d'encodeur sous-échantillonnées). Elle est égale à `left_context + 1` (la trame courante plus le contexte gauche), de sorte que le contexte d'attention gauche est `sliding_window - 1` — identique pour tous les lookaheads pris en charge.

default_num_lookahead_tokens (`int`, *facultatif*, valeur par défaut 13) : Le contexte d'attention à droite (lookahead, en trames d'encodeur sous-échantillonnées) utilisé lorsqu'aucun n'est transmis à la méthode forward. L'ensemble des valeurs prises en charge, avec lequel le modèle a été entraîné, est défini sur [NemotronAsrStreamingProcessor](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor).

Ceci est la classe de configuration destinée à stocker la configuration d'un NemotronAsrStreamingForRNNT. Elle est utilisée pour instancier un modèle Nemotron Asr Streaming 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 [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :
```python
>>> from transformers import NemotronAsrStreamingEncoder, NemotronAsrStreamingEncoderConfig

>>> # Initializing a `NemotronAsrStreamingEncoder` configuration
>>> configuration = NemotronAsrStreamingEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingEncoder(configuration)

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

## NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

#### transformers.NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

```python
transformers.NemotronAsrStreamingFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, mel_filters_dtype = 'float32', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L40)

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

hop_length (`int`, *facultatif*, par défaut 160) : Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel.

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) : La longueur de la fenêtre pour le calcul de la STFT.

preemphasis (`float`, *facultatif*, par défaut 0.97) : Coefficient du filtre de préaccentuation. 0.0 signifie qu'aucun filtre de préaccentuation n'est appliqué.

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

mel_filters_dtype (`str`, *facultatif*, valeur par défaut `"float32"`) : Précision de la banque de filtres mel et de la fenêtre STFT stockées. Certains points de contrôle conservent ces constantes dans une précision réduite (`"bfloat16"` pour Nemotron 3.5 Transcribe) : la banque de filtres et la fenêtre sont alors arrondies à ce type de données lors du calcul des caractéristiques, de sorte que les caractéristiques log-mel correspondent à la chaîne de traitement d'origine ; le spectrogramme lui-même est toujours calculé en float32.

Construit un extracteur de fonctionnalités NemotronAsrStreaming.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/main/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.

Cette classe extrait les caractéristiques de la banque de filtres mel à partir de la parole brute à l’aide d’une implémentation numpy personnalisée de la `Short Time Fourier Transform`, qui doit correspondre à l’équivalent `torch.stft` de pytorch.

## NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

#### transformers.NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

```python
transformers.NemotronAsrStreamingProcessor(feature_extractor, tokenizer, blank_token = '<blank>', supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L34)

**Paramètres :**

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

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

blank_token (`str`, *facultatif*, valeur par défaut `"<blank>"`) : Jeton vide pour le décodage RNN-T.

supported_num_lookahead_tokens (`list[int]`, *facultatif*) : Contextes d'attention à droite (lookaheads, dans les trames d'encodeur sous-échantillonnées) avec lesquels le modèle a été entraîné. Le processeur est la source unique de vérité pour cet ensemble : `set_num_lookahead_tokens()` le valide en conséquence. Par défaut, l'ensemble conscient du cache NeMo `[13, 6, 1, 0]` est utilisé.

default_num_lookahead_tokens (`int`, *facultatif*) : Le contexte droit utilisé pour dimensionner les blocs de streaming et émis par [__call__()](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__) ; modifiez-le avec `set_num_lookahead_tokens()`. Par défaut, il correspond à la première entrée de `supported_num_lookahead_tokens`.

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

[NemotronAsrStreamingProcessor](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) offre toutes les fonctionnalités de [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) et de [ParakeetTokenizer](/docs/transformers/main/fr/model_doc/parakeet#transformers.ParakeetTokenizer). Consultez [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) et [~ParakeetTokenizer](/docs/transformers/main/fr/model_doc/parakeet#transformers.ParakeetTokenizer) pour plus d’informations.

#### __appel__[[transformers.NemotronAsrStreamingProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], text: str | list[str] | list[list[str]] | None = None, sampling_rate: int | None = None, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L83)

**Paramètres :**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio.

text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

sampling_rate (`int`, *facultatif*) : La fréquence d'échantillonnage de l'audio d'entrée, en Hz. Elle doit correspondre à la fréquence d'échantillonnage attendue par l'extracteur de caractéristiques (16000 Hz par défaut). Si elle est fournie, elle est validée par rapport à la fréquence d'échantillonnage attendue par le processeur, et une erreur est levée en cas de non-concordance. Si elle n'est pas fournie, un avertissement est émis et la fréquence d'échantillonnage par défaut est supposée.

is_streaming (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut traiter l'audio en mode streaming. Si `True`, l'audio peut être transmis par morceaux, en utilisant `is_first_audio_chunk` pour distinguer le premier morceau des suivants.

is_first_audio_chunk (`bool`, *facultatif*, valeur par défaut `True`) : Indique si l'audio actuel est le premier fragment d'une session de streaming. L'extracteur de caractéristiques utilise `center=True` pour le premier fragment (et pour un usage hors ligne) et `center=False` pour les fragments suivants, afin que la STFT par fragment reproduise, image par image, un passage unique sur l'énoncé complet. Doit être `True` lorsque `is_streaming=False`.

return_mm_token_type_ids (`bool`, *kwargs*) : Indique s'il faut retourner les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (`bool`, *kwargs*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement multimodal et son remplacement.

return_tensors (`str` ou [TensorType](/docs/transformers/main/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.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

**Retourne :** [BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature)

les sorties du feature-extractor (et du tokenizer optionnel), complétées par :

- **num_lookahead_tokens** -- Le contexte d'attention à droite (lookahead, en trames d'encodeur sous-échantillonnées), c'est-à-dire `default_num_lookahead_tokens` (défini via `set_num_lookahead_tokens()`). À transmettre au forward du modèle/encodeur (ou à `generate`) ; il joue le rôle de `num_delay_tokens` de Voxtral Realtime.

#### decode[[transformers.NemotronAsrStreamingProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L166)

Transmet les arguments à [decode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) et post-traite les horodatages au niveau des jetons (si `durations` sont fournis), comme dans la bibliothèque NeMo.

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

#### transformers.NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

```python
transformers.NemotronAsrStreamingEncoderModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, cache: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L326)

**Paramètres :**

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

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de 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 sélectionnées dans `[0, 1]` :  - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**.

cache (`Cache`, *facultatif*) : Mémorisation de la fenêtre glissante K/V de l'attention mise à jour par l'encodeur. À transmettre à l'appel du segment suivant.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *facultatif*) : cache de streaming unifié qui sert de support aux couches Conv2d de sous-échantillonnage et au Conv1d en profondeur du conformer.

Étend `ParakeetEncoderModelOutput` avec des caches de streaming facultatifs. Les caches ne sont remplis que pour les modèles prenant en compte le cache lorsque `use_cache=True`.

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

#### transformers.NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

```python
transformers.NemotronAsrStreamingRNNTOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, encoder_cache: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_cache (`Cache`, *facultatif*) : cache de fenêtre glissante K/V de l'attention de l'encodeur mis à jour, renvoyé lors de l'encodage audio avec `use_cache=True` (streaming conscient du cache). Transmettez-le au forward du chunk suivant. padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *facultatif*) : cache de convolution de streaming unifié mis à jour (Conv2d de sous-échantillonnage + Conv1d en profondeur du conformer), renvoyé lors de l'encodage audio avec `use_cache=True`. Transmettez-le au forward du chunk suivant.

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

#### transformers.NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

```python
transformers.NemotronAsrStreamingEncoder(config: NemotronAsrStreamingEncoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L878)

**Paramètres :**

config ([NemotronAsrStreamingEncoderConfig](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle NemotronAsrStreaming Encoder, basé sur l'architecture [Fast Conformer](https://huggingface.co/papers/2305.05084).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.NemotronAsrStreamingEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, cache: transformers.cache_utils.Cache | None = None, output_attention_mask: bool = True, use_cache: bool | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L901)

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

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

cache (`Cache`, *facultatif*) : cache K/V à fenêtre glissante (`DynamicCache` construit à partir de `config.sliding_window`) pour une attention de streaming prenant en compte le cache.

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.

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

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *facultatif*) : cache de streaming unifié qui sert de support aux couches Conv2d de sous-échantillonnage et au Conv1d en profondeur du conformer.

num_lookahead_tokens (`int`, *facultatif*) : Remplacement du contexte d'attention à droite (anticipation, dans les trames d'encodeur sous-échantillonnées) pour ce passage avant. Combiné avec le contexte à gauche `config.sliding_window - 1`. Par défaut, `config.default_num_lookahead_tokens`.

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

Un [BaseModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 [NemotronAsrStreamingEncoder](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoder) 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.
- **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, NemotronAsrStreamingEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = NemotronAsrStreamingEncoder.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)
```

## NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

#### transformers.NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

```python
transformers.NemotronAsrStreamingForRNNT(config: NemotronAsrStreamingConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**Paramètres :**

config ([NemotronAsrStreamingConfig](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

NemotronAsrStreaming Encoder avec une tête RNN-T (Recurrent Neural Network Transducer).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.NemotronAsrStreamingForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**Paramètres :**

input_features (`torch.Tensor` 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 `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)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, 1)`, *facultatif*) : Identifiants des jetons d'entrée du décodeur pour une inférence en une étape.

decoder_cache (`NemotronAsrStreamingRNNTDecoderCache`, *facultatif*) : Cache du LSTM du décodeur. Réutilisé lors des prédictions vides pour passer l'étape du LSTM.

use_decoder_cache (`bool`, *facultatif*) : Indique s'il faut allouer et utiliser un cache de décodeur lorsqu'aucun n'est fourni.

encoder_outputs (`NemotronAsrStreamingEncoderModelOutput`, *facultatif*) : Sorties de l'encodeur précalculées (last_hidden_state, pooler_output, ...).

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]`.

num_lookahead_tokens (`int`, *facultatif*) : Contexte d'attention à droite (lookahead, dans les trames d'encodeur sous-échantillonnées) transmis à l'encodeur. La valeur par défaut est `config.encoder_config.default_num_lookahead_tokens`.

**Retourne :** [NemotronAsrStreamingRNNTOutput](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) ou `tuple(torch.Tensor)`

Un [NemotronAsrStreamingRNNTOutput](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) 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 [NemotronAsrStreamingForRNNT](/docs/transformers/main/fr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingForRNNT) 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.

- **encoder_cache** (`Cache`, *facultatif*) -- Mise à jour du cache de fenêtre glissante K/V de l'attention de l'encodeur, renvoyée lors de l'encodage d'audio avec `use_cache=True` (streaming conscient du cache). Transmettez-le au forward du prochain fragment.
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *facultatif*) -- Cache unifié de convolution streaming mis à jour (Conv2d de sous-échantillonnage + Conv1d en profondeur de conformer), renvoyé lors de l'encodage audio avec `use_cache=True`. Transmettez-le au forward du chunk suivant.

Exemple :

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

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = NemotronAsrStreamingForRNNT.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"])
>>> outputs = model(**inputs)
```

#### generate[[transformers.NemotronAsrStreamingForRNNT.generate]]

```python
generate(inputs = None, generation_config = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/generation_nemotron_asr_streaming.py#L213)

