Hugging Face's logo

Transformers documentation

Nemotron ASR Streaming

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2023-05-08 et ajouté à Hugging Face Transformers le 2026-06-18.

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

Pipeline
AutoModel
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)

Transcription en streaming

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 :

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 :

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

classe transformers.NemotronAsrStreamingConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 1025decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 0blank_token_id: int = 1024 )

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, 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 é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") — Fonction d'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, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • blank_token_id (int, facultatif, 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nvidia/nemotron-speech-streaming-en-0.6b

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import 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

classe transformers.NemotronAsrStreamingEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02sliding_window: int = 71default_num_lookahead_tokens: int = 13 )

Paramètres

  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, 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, par défaut 4096) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du 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 des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention.
  • convolution_bias (bool, facultatif, 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) — Taille du noyau des couches de convolution de sous-échantillonnage.
  • subsampling_conv_stride (int, facultatif, valeur par défaut 2) — Le pas des couches de convolution de sous-échantillonnage.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à 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, par défaut 0.1) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir 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 appliqué aux 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, 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • sliding_window (int, facultatif, 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 au forward. L’ensemble des valeurs prises en charge avec lesquelles le modèle a été entraîné se trouve sur 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nvidia/nemotron-speech-streaming-en-0.6b

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import 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

classe transformers.NemotronAsrStreamingFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0mel_filters_dtype = 'float32'**kwargs )

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) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée 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, par défaut 512) — Taille de la transformée de Fourier.
  • win_length (int, facultatif, par défaut 400) — La longueur de la fenêtre pour le calcul de la STFT.
  • preemphasis (float, facultatif, valeur 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 à des silences.
  • mel_filters_dtype (str, facultatif, 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 fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à 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

classe transformers.NemotronAsrStreamingProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'supported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = None )

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, 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 pris en compte par le cache NeMo est [13, 6, 1, 0].
  • default_num_lookahead_tokens (int, facultatif) — Le contexte droit utilisé pour dimensionner les blocs de streaming et émis par 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 offre toutes les fonctionnalités de NemotronAsrStreamingFeatureExtractor et de ParakeetTokenizer. Consultez ~NemotronAsrStreamingFeatureExtractor et ~ParakeetTokenizer pour plus d’informations.

__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 = Nonesampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool | None = True**kwargs: *<class 'transformers.models.nemotron_asr_streaming.processing_nemotron_asr_streaming.NemotronAsrStreamingProcessorKwargs'> ) → BatchFeature

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/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage 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 de caractères (chaînes pré-tokenisées). Si vous passez 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, 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, frame par frame, un passage unique sur l’énoncé complet. Doit être True lorsque is_streaming=False.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (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

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

  • num_lookahead_tokens — Le contexte d’attention à droite (lookahead, dans les trames d’encodeur sous-échantillonnées), c’est-à-dire default_num_lookahead_tokens (défini via set_num_lookahead_tokens()). Transmettez-le au forward du modèle/encodeur (ou à generate) ; il joue le rôle de num_delay_tokens de Voxtral Realtime.

décoder

< >

( *argsdurations = None**kwargs )

Transmet les arguments à decode() et post-traite les horodatages au niveau des jetons (si durations sont fournis), comme dans la bibliothèque NeMo.

NemotronAsrStreamingEncoderModelOutput

classe transformers.NemotronAsrStreamingEncoderModelOutput

< >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

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

    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 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. Les valeurs du masque sont sélectionnées dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.
  • past_key_values (Cache, facultatif) — Mise à jour du cache de fenêtre glissante K/V de l'attention de l'encodeur. À passer à l'appel du prochain fragment.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) — Cache de streaming unifié servant de support aux couches Conv2d de sous-échantillonnage et au Conv1d en profondeur du conformer.

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

NemotronAsrStreamingRNNTOutput

classe transformers.NemotronAsrStreamingRNNTOutput

< >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneloss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedecoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

encoder_past_key_values (Cache, facultatif) : Mise à jour du cache de fenêtre glissante K/V de l’attention de l’encodeur, renvoyée lors de l’encodage audio avec use_cache=True (diffusion prenant en compte le cache). À transmettre au forward du prochain fragment. padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) : Mise à jour du cache de convolution de diffusion unifié (Conv2d de sous-échantillonnage + Conv1d en profondeur du conformer), renvoyée lors de l’encodage audio avec use_cache=True. À transmettre au forward du prochain fragment.

NemotronAsrStreamingEncoder

classe transformers.NemotronAsrStreamingEncoder

< >

( config: NemotronAsrStreamingEncoderConfig )

Paramètres

  • config (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() pour charger les poids du modèle.

Le modèle NemotronAsrStreaming Encoder, basé sur l'architecture Fast Conformer.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneoutput_attention_mask: bool = Trueuse_cache: bool | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

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 masqués.

    Qu'est-ce que les masques d'attention ?

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (Cache, facultatif) — Mémoire tampon K/V à fenêtre glissante (DynamicCache construit à partir de config.sliding_window) pour l’attention en streaming prenant en compte le cache.
  • output_attention_mask (bool, facultatif, 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 clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) — Cache de streaming unifié servant 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 (lookahead, en trames d'encodeur sous-échantillonnées) pour ce passage en avant. Combiné au contexte à gauche config.sliding_window - 1. Par défaut, config.default_num_lookahead_tokens.

Retourne

BaseModelOutput ou tuple(torch.Tensor)

Un BaseModelOutput 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 (None) et des entrées.

La méthode forward de 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).

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

Exemple :

>>> from transformers import AutoProcessor, 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

classe transformers.NemotronAsrStreamingForRNNT

< >

( config: NemotronAsrStreamingConfig )

Paramètres

  • config (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() 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → NemotronAsrStreamingRNNTOutput or tuple(torch.Tensor)

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. Consultez 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 précalculées de l’encodeur (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 -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, en trames d'encodeur sous-échantillonnées) transmis à l'encodeur. Valeur par défaut : config.encoder_config.default_num_lookahead_tokens.

Retourne

NemotronAsrStreamingRNNTOutput ou tuple(torch.Tensor)

Un NemotronAsrStreamingRNNTOutput 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 (None) et des entrées.

La méthode forward de 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_past_key_values (Cache, facultatif) — Mise à jour du cache de fenêtre glissante des K/V de l’attention de l’encodeur, renvoyée lors de l’encodage d’audio avec use_cache=True (streaming conscient du cache). À transmettre au forward du chunk suivant.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) — Cache unifié de convolution streaming 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.

Exemple :

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

< >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3.5 Transcribe NeuCodec→