Hugging Face's logo

Transformers documentation

Nemotron 3 Diarization

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
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é contribué à Hugging Face Transformers le 2026-09-23.

Nemotron 3 Diarization

Aperçu

Nemotron 3 Diarization est un modèle de diarisation de locuteurs en flux à poids ouverts, conçu pour déterminer « qui a parlé quand » dans des audio réels. Il prend en charge l’inférence en flux et hors ligne, gère jusqu’à huit locuteurs et ordonne les sorties des locuteurs selon leur première apparition dans l’audio d’entrée.

Le modèle utilise le cache de locuteurs par ordre d’arrivée (AOSC) 1 et la file FIFO introduits pour Streaming Sortformer 1, 2. Un seul point de contrôle prend en charge des profils de latence configurables, allant d’un tampon d’entrée de 80 ms à un tampon de type hors ligne de 30,4 s, ainsi qu’une résolution de trame de sortie configurable par multiples de 10 ms. Avec une inférence par blocs, la durée maximale de l’audio n’est pas limitée.

Utilisation

Hors ligne

import torch
from transformers import AutoModelForAudioFrameClassification, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/Nemotron-3-Diarization"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map="auto")

sampling_rate = processor.feature_extractor.sampling_rate
audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/diarization_example.mp3",
    sampling_rate=sampling_rate,
)
inputs = processor(audio, sampling_rate=sampling_rate).to(model.device, dtype=model.dtype)

with torch.inference_mode():
    logits = model(**inputs).logits  # (1, num_frames, 8), one frame every 10 ms

segments = processor.extract_speaker_dict(logits, inputs.attention_mask)[0]
for segment in segments:
    print(f"speaker_{segment['Speaker']}: {segment['Start']:.2f}s - {segment['End']:.2f}s")

Streaming

L’audio arrive par morceaux, et chaque appel de forward en traite un : le processeur le découpe pour son streaming_mode et ajoute num_lookahead_frames, le nombre de frames de lookahead en fin de morceau auxquelles le modèle prête attention mais qu’il ne note pas, car elles ouvrent le morceau suivant. Le forward renvoie le speaker_cache à transmettre à l’appel suivant. Le dernier morceau d’une session est extrait avec is_last_audio_chunk=True : il n’a pas de lookahead, donc chaque frame restante est notée.

streaming_modeLatence¹
"low_latency" (par défaut)1.04 s
"very_low_latency"0.64 s
"ultra_low_latency"0.32 s

¹ Audio à attendre avant que le modèle ne s'exécute sur un fragment : le fragment plus son anticipation, en excluant le temps de calcul.

import torch
from transformers import AutoModelForAudioFrameClassification, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/Nemotron-3-Diarization"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map="auto")
processor.set_streaming_mode("low_latency")  # the default, can also be "very_low_latency" and "ultra_low_latency"
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/diarization_example.mp3",
    sampling_rate=sampling_rate,
)


def inputs_generator():
    """Yields the processor outputs of each chunk."""
    yield processor(
        audio[: processor.num_samples_first_audio_chunk],
        sampling_rate=sampling_rate,
        is_streaming=True,
        is_first_audio_chunk=True,
    )

    mel_frame_idx = processor.num_mel_frames_per_step
    start_idx = processor.audio_chunk_start(mel_frame_idx)
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) <= audio.shape[0]:
        yield processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
        )
        mel_frame_idx += processor.num_mel_frames_per_step
        start_idx = processor.audio_chunk_start(mel_frame_idx)

    # the audio ended: the frames left in the buffer are the last ones of the session
    yield processor(
        audio[start_idx:],
        sampling_rate=sampling_rate,
        is_streaming=True,
        is_first_audio_chunk=False,
        is_last_audio_chunk=True,
    )


speaker_cache, logits = None, []
with torch.inference_mode():
    for inputs in inputs_generator():
        inputs = inputs.to(model.device, dtype=model.dtype)
        # `inputs` carries `num_lookahead_frames` for every chunk but the last, `speaker_cache` links the chunks
        outputs = model(**inputs, speaker_cache=speaker_cache)
        logits.append(outputs.logits)  # the chunk's frames, without its look-ahead
        speaker_cache = outputs.speaker_cache

logits = torch.cat(logits, dim=1)  # (1, num_frames, 8), one frame every 10 ms
segments = processor.extract_speaker_dict(logits)[0]  # [{"Start": 0.0, "End": 15.43, "Speaker": 0}, ...]

Faire tourner ça à plein régime

L’entrée de l’encodeur d’une étape de streaming est [speaker cache | FIFO | chunk], dont la longueur varie au fur et à mesure que le cache et le FIFO se remplissent et se vident : torch.compile recompilerait environ une centaine de fois par session. Rembourrer chaque étape jusqu’à la plus grande fenêtre du mode fixe la forme. Les positions repartent de zéro à chaque chunk, de sorte que le rembourrage à droite ne modifie pas les trames valides :

import torch.nn.functional as F

chunk_length, chunk_right_context = processor.streaming_modes[processor.streaming_mode]
max_window = (
    model.config.streaming_config.speaker_cache_length
    + model.config.streaming_config.fifo_length
    + chunk_length
    + chunk_right_context
)
encoder = model.model
compiled_forward = torch.compile(encoder.forward, mode="reduce-overhead", fullgraph=True, dynamic=False)


def padded_forward(inputs_embeds, attention_mask=None, position_ids=None, **kwargs):
    batch_size, num_frames, _ = inputs_embeds.shape
    if attention_mask is None:
        attention_mask = inputs_embeds.new_ones(batch_size, num_frames, dtype=torch.bool)
    padding = max_window - num_frames
    hidden_states = compiled_forward(
        inputs_embeds=F.pad(inputs_embeds, (0, 0, 0, padding)),
        attention_mask=F.pad(attention_mask.bool(), (0, padding), value=False),
        position_ids=torch.arange(max_window, device=inputs_embeds.device)[None, :],
        **kwargs,
    )
    return hidden_states[:, :num_frames].clone()  # CUDA graphs reuse the output buffer


encoder.forward = padded_forward

# warm up before the session: compiles, then records the CUDA graph, so the first real chunk runs at full speed
with torch.inference_mode():
    for _ in range(3):
        hidden_size = model.config.audio_config.hidden_size
        padded_forward(torch.zeros(1, max_window, hidden_size, device=model.device, dtype=model.dtype))

La boucle de streaming ci-dessus est alors compilée une seule fois. Le passage avant hors ligne effectue le même fractionnement, de sorte que le même wrapper s’applique avec config.fifo_length, config.chunk_left_context, config.chunk_length et config.chunk_right_context dans max_window.

Accélération par rapport à l'exécution immédiate (A100, taille de lot 1)float32bfloat16
streaming, par étape1.2x4.4x
hors ligne, enregistrement de 488 s1.3x2.8x

Nemotron3DiarizationConfig

classe transformers.Nemotron3DiarizationConfig

< >

( 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 = Noneaudio_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationAudioConfig | dict | None = Nonehead_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationHeadConfig | dict | None = Nonestreaming_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationStreamingConfig | dict | None = Nonechunk_length: int = 340chunk_right_context: int = 40chunk_left_context: int = 0fifo_length: int = 40speaker_cache_update_period: int = 300initializer_range: float = 0.02 )

Paramètres

  • audio_config (Nemotron3DiarizationAudioConfig ou dict, facultatif) — Configuration de l'encodeur audio du transformer. Par défaut, Nemotron3DiarizationAudioConfig().
  • head_config (Nemotron3DiarizationHeadConfig ou dict, facultatif) — Configuration de la tête de locuteur. Par défaut, Nemotron3DiarizationHeadConfig().
  • streaming_config (Nemotron3DiarizationStreamingConfig ou dict, facultatif) — Politique de cache des locuteurs et tailles des files FIFO du mode streaming. Valeur par défaut : Nemotron3DiarizationStreamingConfig().
  • chunk_length (int, facultatif, valeur par défaut 340) — Mode hors ligne : nombre de trames d’encodeur par bloc lorsqu’un enregistrement complet est traité en une seule passe avant. En mode streaming, le bloc correspond à l’entrée de chaque passe avant.
  • chunk_right_context (int, facultatif, valeur par défaut 40) — Mode hors ligne : nombre de trames encodeur en avance que chaque bloc prend dans les blocs suivants. En mode streaming, l'avance est de num_lookahead_frames pour chaque passe avant.
  • chunk_left_context (int, facultatif, valeur par défaut 0) — Mode hors ligne : nombre de trames encodeur de retour en arrière que chaque bloc reprend des blocs précédents, insérées entre les trames mises en cache et le bloc. Comme le retour en avant, elles sont prises en compte mais ne sont ni notées ni poussées dans la file FIFO. En mode streaming, le retour en arrière est num_lookback_frames de chaque passe avant.
  • fifo_length (int, facultatif, valeur par défaut 40) — Mode hors ligne : capacité de la file FIFO des trames encodeur les plus récentes. Le mode en continu utilise streaming_config.fifo_length.
  • speaker_cache_update_period (int, facultatif, valeur par défaut 300) — Mode hors ligne : nombre de trames d’encodeur déplacées de la file FIFO vers le cache de locuteur lorsque la file déborde. Le mode en flux utilise streaming_config.speaker_cache_update_period.
  • 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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Nemotron3DiarizationModel. Elle est utilisée pour instancier un modèle de diarisation Nemotron3 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-3-Diarization

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.

Nemotron3DiarizationAudioConfig

classe transformers.Nemotron3DiarizationAudioConfig

< >

( 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 = 512intermediate_size: int = 2048num_hidden_layers: int = 31num_attention_heads: int = 8num_key_value_heads: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 5000initializer_range: float = 0.02rope_parameters: dict | None = Noneattention_dropout: float | int = 0.0num_mel_bins: int = 128subsampling_factor: int = 8 )

Paramètres

  • hidden_size (int, facultatif, par défaut 512) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 2048) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 31) — 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) — Ceci est le nombre de têtes key_value à utiliser pour implémenter la Grouped Query Attention. Si num_key_value_heads=num_attention_heads, le modèle utilisera la Multi Head Attention (MHA), si num_key_value_heads=1 le modèle utilisera la Multi Query Attention (MQA), sinon la GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite par moyennage (meanpooling) de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut est num_attention_heads.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, facultatif, par défaut 5000) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • 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.
  • rope_parameters (dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • num_mel_bins (int, facultatif, par défaut 128) — Nombre de caractéristiques mel utilisées par trame d’entrée. Doit correspondre à la valeur utilisée dans la classe AutoFeatureExtractor.
  • subsampling_factor (int, facultatif, valeur par défaut 8) — Nombre de trames consécutives du spectrogramme empilées en une trame d’encodeur. Le classifieur effectue un suréchantillonnage de ses sorties avec le même facteur, de sorte que l’activité des locuteurs est prédite à la fréquence des trames du spectrogramme.

Ceci est la classe de configuration destinée à stocker la configuration d'un Nemotron3DiarizationModel. Elle est utilisée pour instancier un modèle de diarisation Nemotron3 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-3-Diarization

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.

Nemotron3DiarizationHeadConfig

classe transformers.Nemotron3DiarizationHeadConfig

< >

( 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 = 192num_speakers: int = 8audio_hidden_size: int = 512subsampling_factor: int = 8 )

Paramètres

  • hidden_size (int, facultatif, par défaut 192) — Taille cachée de la tête du locuteur : la sortie de l'encodeur est projetée sur cette taille, et l'upsampler et le classifieur la conservent.
  • num_speakers (int, facultatif, valeur par défaut 8) — Nombre maximal d’orateurs, c’est-à-dire le nombre de sorties d’activité par trame. Les orateurs sont ordonnés selon leur première apparition dans l’audio.
  • audio_hidden_size (int, facultatif, valeur par défaut 512) — Taille cachée de la sortie de l'encodeur à partir de laquelle la tête projette. Doit correspondre à Nemotron3DiarizationAudioConfig.hidden_size.
  • subsampling_factor (int, facultatif, valeur par défaut 8) — Facteur de suréchantillonnage de la tête, pour revenir au taux d'échantillonnage du spectrogramme. Doit correspondre à Nemotron3DiarizationAudioConfig.subsampling_factor.

Ceci est la classe de configuration destinée à stocker la configuration d'un Nemotron3DiarizationModel. Elle est utilisée pour instancier un modèle de diarisation Nemotron3 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-3-Diarization

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.

Nemotron3DiarizationStreamingConfig

classe transformers.Nemotron3DiarizationStreamingConfig

< >

( 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 = Nonefifo_length: int = 264speaker_cache_update_period: int = 222speaker_cache_length: int = 264speaker_cache_silence_frames_per_speaker: int = 1prediction_score_threshold: float = 0.25latest_frames_score_boost: float = 0.05strong_boost_rate: float = 0.75weak_boost_rate: float = 1.5min_positive_scores_rate: float = 0.5num_speakers: int = 8subsampling_factor: int = 8 )

Paramètres

  • fifo_length (int, facultatif, valeur par défaut 264) — Capacité de la file FIFO des trames encodeur les plus récentes en mode streaming (le mode hors ligne utilise Nemotron3DiarizationConfig.fifo_length).
  • speaker_cache_update_period (int, facultatif, valeur par défaut 222) — Nombre de trames encodeur déplacées de la file FIFO vers le cache locuteur lorsque la file déborde, en mode streaming (le mode hors ligne utilise Nemotron3DiarizationConfig.speaker_cache_update_period).
  • speaker_cache_length (int, facultatif, valeur par défaut 264) — Capacité du cache Arrival-Order Speaker. Doit être au moins (1 + speaker_cache_silence_frames_per_speaker) * num_speakers.
  • speaker_cache_silence_frames_per_speaker (int, facultatif, valeur par défaut : 1) — Nombre d’emplacements de cache par locuteur réservés à l’embedding de silence appris lorsque le cache est compressé.
  • prediction_score_threshold (float, facultatif, valeur par défaut 0,25) — Limite inférieure des probabilités des locuteurs avant de prendre leur logarithme dans les scores des trames du cache des locuteurs.
  • latest_frames_score_boost (float, facultatif, valeur par défaut 0.05) — Bonus de score accordé aux frames nouvellement ajoutées au cache du locuteur lors de sa compression.
  • strong_boost_rate (float, facultatif, valeur par défaut 0,75) — Fraction du budget de cache par locuteur dont les meilleures images reçoivent un renforcement de score important, afin que chaque locuteur conserve au moins ce nombre d’images dans le cache.
  • weak_boost_rate (float, facultatif, valeur par défaut 1.5) — Fraction du budget de cache par locuteur dont les meilleures images reçoivent un bonus de score faible, ce qui empêche un locuteur de dominer le cache.
  • min_positive_scores_rate (float, facultatif, valeur par défaut 0.5) — Fraction du budget de cache par locuteur : un locuteur ayant au moins ce nombre de frames positivement notés a ses frames non positifs (parole superposée) exclus du cache.
  • num_speakers (int, facultatif, valeur par défaut 8) — Nombre d’orateurs suivis par le cache d’orateurs. Doit correspondre à Nemotron3DiarizationHeadConfig.num_speakers.
  • subsampling_factor (int, facultatif, valeur par défaut 8) — Nombre de trames de probabilité de locuteur par trame d’encodeur. Doit correspondre à Nemotron3DiarizationAudioConfig.subsampling_factor.

Ceci est la classe de configuration destinée à stocker la configuration d'un Nemotron3DiarizationModel. Elle est utilisée pour instancier un modèle de diarisation Nemotron3 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-3-Diarization

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.

Nemotron3DiarizationAudioModel

classe transformers.Nemotron3DiarizationAudioModel

< >

( config: Nemotron3DiarizationAudioConfig )

Paramètres

  • config (Nemotron3DiarizationAudioConfig) — 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 de diarisation Nemotron3 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = 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), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de NemotronAsrStreamingFeatureExtractor. Voir NemotronAsrStreamingFeatureExtractor.__call__() pour plus de détails (Nemotron3DiarizationProcessor utilise NemotronAsrStreamingFeatureExtractor 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 ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • position_ids (torch.Tensor 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 ?

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

La méthode forward du modèle Nemotron3DiarizationAudioModel 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.

Nemotron3DiarizationModel

classe transformers.Nemotron3DiarizationModel

< >

( config: Nemotron3DiarizationConfig )

Paramètres

  • config (Nemotron3DiarizationConfig) — 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 Nemotron3Diarization sans le classificateur de locuteurs : encode un bloc (avec ses trames mises en cache) et rééchantillonne les trames de l'encodeur pour revenir au taux de trames du spectrogramme. Il ne conserve aucun état de streaming, voir Nemotron3DiarizationForAudioFrameClassification pour le calcul en avant par blocs.

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] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = 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), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de NemotronAsrStreamingFeatureExtractor. Voir NemotronAsrStreamingFeatureExtractor.__call__() pour plus de détails (Nemotron3DiarizationProcessor utilise NemotronAsrStreamingFeatureExtractor 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 ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • position_ids (torch.Tensor 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 ?

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

La méthode forward du Nemotron3DiarizationModel 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.

Nemotron3DiarizationProcessor

classe transformers.Nemotron3DiarizationProcessor

< >

( feature_extractorsubsampling_factor = 8streaming_modes = Nonestreaming_mode = 'low_latency' )

Paramètres

  • feature_extractor (NemotronAsrStreamingFeatureExtractor) — L'extracteur de caractéristiques est une entrée obligatoire.
  • subsampling_factor (int, facultatif, valeur par défaut 8) — Nombre de trames mel par trame d’encodeur, reflétant Nemotron3DiarizationAudioConfig.subsampling_factor.
  • streaming_modes (dict[str, tuple[int, int]], facultatif) — Modes de streaming pris en charge par le point de contrôle, associant le nom à (chunk_length, chunk_right_context) en trames encodeur. Le processeur est la source unique de vérité pour cet ensemble : set_streaming_mode() valide à son encontre. Par défaut, les modes de la fiche modèle, "low_latency" (9, 4), "very_low_latency" (6, 2) et "ultra_low_latency" (3, 1).
  • streaming_mode (str, facultatif, par défaut "low_latency") — Mode de streaming des sessions, l’un des streaming_modes ; modifiable avec set_streaming_mode(). L’utilisation hors ligne l’ignore.

Construit un Nemotron3DiarizationProcessor qui encapsule un extracteur de caractéristiques dans un processeur unique.

Nemotron3DiarizationProcessor offre toutes les fonctionnalités de NemotronAsrStreamingFeatureExtractor. Consultez ~NemotronAsrStreamingFeatureExtractor pour plus d’informations.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]sampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool = Trueis_last_audio_chunk: bool = False**kwargs: *<class 'transformers.models.nemotron3_diarization.processing_nemotron3_diarization.Nemotron3DiarizationProcessorKwargs'> ) → 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.
  • sampling_rate (int, facultatif) — Fréquence d’échantillonnage de l’audio d’entrée, en Hz. Validée par rapport à la fréquence d’échantillonnage attendue par l’extracteur de caractéristiques (16000 Hz) lorsqu’elle est fournie.
  • is_streaming (bool, facultatif, par défaut False) — Indique si l’audio est un fragment d’une session de streaming, is_first_audio_chunk et is_last_audio_chunk permettant de distinguer le premier et le dernier fragment des autres. Les tailles des fragments sont celles de streaming_mode, modifiables via set_streaming_mode(). Tout fragment sauf le dernier doit contenir exactement num_samples_first_audio_chunk échantillons audio pour le premier, et num_samples_per_audio_chunk pour les suivants.
  • is_first_audio_chunk (bool, facultatif, par défaut True) — Indique s'il s'agit du premier fragment d'une session de streaming. L'extracteur de caractéristiques centre les fenêtres d'analyse (center=True) pour le premier fragment et pour une utilisation hors ligne, et ne le fait pas (center=False) pour les fragments suivants, afin que le spectrogramme par fragment reproduise, frame par frame, un passage unique sur l'énoncé complet. Doit être True lorsque is_streaming=False.
  • is_last_audio_chunk (bool, facultatif, par défaut False) — Indique si ce fragment met fin à la session de streaming. Un fragment de session se termine par des trames d’encodeur de contexte avant chunk_right_context que le modèle évalue uniquement à l’étape suivante, et avec lesquelles son fragment suivant s’ouvre. Le dernier fragment n’a pas d’étape suivante, donc chacune de ses trames est évaluée, quel que soit leur nombre, et sa fin est complétée par des zéros, de la même manière qu’un passage sur une énonciation complète remplit la fin de l’audio, afin de produire les dernières trames de l’énonciation. Doit être False 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 de l’extracteur de caractéristiques, input_features et attention_mask. En mode streaming, les trames de fin dont la fenêtre d’analyse dépasse un chunk autre que le dernier sont supprimées, de sorte que input_features contient exactement les trames du chunk et peut être transmis au modèle tel quel, et chaque chunk sauf le dernier porte également num_lookahead_frames, le nombre de ses trames de prévision de l’encodeur de fin, ce qui place le modèle en mode streaming.

Nemotron3DiarizationSpeakerCache

classe transformers.Nemotron3DiarizationSpeakerCache

< >

( config: Nemotron3DiarizationStreamingConfigfifo_length: int | None = Nonespeaker_cache_update_period: int | None = None )

Paramètres

  • config (Nemotron3DiarizationStreamingConfig) — Politique de cache des locuteurs et tailles des files FIFO du mode streaming.
  • fifo_length (int, facultatif) — Capacité de la file FIFO des trames encodeur les plus récentes. Valeur par défaut : config.fifo_length.
  • speaker_cache_update_period (int, facultatif) — Nombre de trames encodeur déplacées de la file FIFO vers le cache du locuteur lorsque la file déborde. La valeur par défaut est config.speaker_cache_update_period.

État du streaming de Nemotron3DiarizationForAudioFrameClassification : le cache de locuteurs par ordre d’arrivée et la file FIFO des trames encodeur les plus récentes, auxquelles chaque bloc est soumis.

update

< >

( chunk_input_embeds: Tensorchunk_logits: Tensorsilence_embeds: Tensornum_chunk_frames: intmask: typing.Optional[torch.Tensor] = Nonenum_lookback_frames: int = 0 )

Paramètres

  • chunk_input_embeds (torch.Tensor de forme (batch_size, num_input_frames, hidden_size)) — Entrée de l’encodeur de l’étape : les images mises en cache renvoyées par get_embeds, les images de retour en arrière, le bloc et son anticipation.
  • chunk_logits (torch.Tensor de forme (batch_size, num_input_frames * subsampling_factor, num_speakers)) — Logits des locuteurs de l'étape, utilisés pour évaluer les images lorsque le cache des locuteurs est compressé.
  • silence_embeds (torch.Tensor de forme (hidden_size,)) — Embedding de silence appris, servant à remplir les emplacements de silence réservés d'un cache compressé.
  • num_chunk_frames (int) — Nombre de trames de chunk suivant les trames mises en cache et les trames de retour en arrière dans chunk_input_embeds. Seules celles-ci rejoignent la file FIFO : les trames de prévision qui les suivent sont à nouveau fournies à l'étape suivante.
  • mask (torch.Tensor de forme (batch_size, num_input_frames), facultatif) — Frames valides de chunk_input_embeds, dont les frames de bourrage reçoivent des probabilités de locuteur nulles.
  • num_lookback_frames (int, facultatif, valeur par défaut 0) — Nombre de frames de retour en arrière entre les frames mises en cache et le chunk dans chunk_input_embeds : frames du chunk précédent renvoyées, déjà poussées avec lui.

Pousse un bloc traité dans la file FIFO, en déplaçant ses trames les plus anciennes vers le cache du haut-parleur en cas de débordement.

Nemotron3DiarizationOutput

classe transformers.Nemotron3DiarizationOutput

< >

( logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Nonespeaker_cache: transformers.models.nemotron3_diarization.modeling_nemotron3_diarization.Nemotron3DiarizationSpeakerCache | None = None )

Paramètres

  • logits (torch.Tensor de forme (batch_size, num_frames, config.head_config.num_speakers)) — Logits d'activité des locuteurs par trame, à la fréquence des trames du spectrogramme. logits.sigmoid() donne la probabilité que chaque locuteur soit actif dans chaque trame ; les locuteurs sont ordonnés selon leur première apparition dans l'audio.
  • hidden_states (tuple[torch.Tensor, ...], facultatif, renvoyé lorsque output_hidden_states=True) — États cachés de l’encodeur pour chaque bloc, dans l’ordre des blocs : l’encodeur s’exécute une fois par bloc, le tuple contient donc config.audio_config.num_hidden_layers + 1 tenseurs par bloc. Leur longueur de séquence correspond à celle du bloc, cadres de cache et d’anticipation inclus.
  • attentions (tuple[torch.Tensor, ...], facultatif, renvoyé lorsque output_attentions=True) — Pondérations d'attention de l'encodeur pour chaque bloc, dans l'ordre des blocs, config.audio_config.num_hidden_layers tenseurs par bloc.
  • speaker_cache (Nemotron3DiarizationSpeakerCache, facultatif, renvoyé en mode streaming) — État de streaming mis à jour, à passer au forward du prochain fragment audio des mêmes flux.

Sortie de Nemotron3DiarizationForAudioFrameClassification.

Nemotron3DiarizationForAudioFrameClassification

classe transformers.Nemotron3DiarizationForAudioFrameClassification

< >

( config: Nemotron3DiarizationConfig )

Paramètres

  • config (Nemotron3DiarizationConfig) — 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.

Modèle de diarisation des locuteurs Streaming Sortformer : prédit, pour chaque trame du spectrogramme, l’activité d’au plus config.head_config.num_speakers locuteurs ordonnés par ordre d’arrivée. L’audio est traité par blocs, chaque bloc portant attention sur quelques trames en avance ainsi que sur le Arrival-Order Speaker Cache et la file FIFO conservés dans un Nemotron3DiarizationSpeakerCache. Un enregistrement complet est découpé en blocs par le forward lui-même (mode hors ligne) ; un flux est alimenté un bloc par forward (mode streaming).

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] = Nonespeaker_cache: transformers.models.nemotron3_diarization.modeling_nemotron3_diarization.Nemotron3DiarizationSpeakerCache | None = Nonenum_lookahead_frames: int | None = Nonenum_lookback_frames: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3DiarizationOutput 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 NemotronAsrStreamingFeatureExtractor. Consultez NemotronAsrStreamingFeatureExtractor.__call__() pour plus de détails (Nemotron3DiarizationProcessor utilise NemotronAsrStreamingFeatureExtractor 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 ?

  • speaker_cache (Nemotron3DiarizationSpeakerCache, facultatif) — État de streaming renvoyé par le forward du chunk précédent des mêmes flux audio.
  • num_lookahead_frames (int, facultatif) — Mode de streaming : nombre de trames encodeur de fin de l'entrée qui ne servent qu'à l'anticipation. Elles sont prises en compte, mais leurs logits ne sont pas renvoyés et elles ne rejoignent pas la file FIFO, car elles ouvrent le prochain bloc. Nemotron3DiarizationProcessor le définit pour chaque bloc sauf le dernier d'une session.

    Ces arguments et num_lookback_frames sélectionnent le mode. Mode streaming, un bloc par passe avant : num_lookahead_frames ou num_lookback_frames est fourni (un premier bloc crée le speaker_cache, les blocs suivants le reçoivent), ou speaker_cache est fourni seul (le dernier bloc de la session, sans anticipation). L’entrée, moins ses cadres de retour arrière et d’anticipation, constitue un bloc, quelle que soit sa longueur, poussé en entier dans la file FIFO dimensionnée par config.streaming_config. Mode hors ligne, aucun des deux n’est fourni : l’entrée est un enregistrement complet, découpé par la passe avant en blocs de config.chunk_length cadres encodeur qui prennent jusqu’à config.chunk_left_context cadres de retour arrière des blocs précédents et jusqu’à config.chunk_right_context cadres d’anticipation des blocs suivants, avec une file FIFO dimensionnée par config.fifo_length ; aucun cache n’est renvoyé.

  • num_lookback_frames (int, facultatif) — Mode streaming : nombre de cadres d’encodeur en tête de l’entrée qui ne servent qu’à la rétrovision, c’est-à-dire la fin du bloc précédent renvoyé avant celui-ci, en plus des cadres de speaker_cache. Ils sont pris en compte, mais leurs logits ne sont pas renvoyés et ils ne rejoignent pas à nouveau la file FIFO. Valeur par défaut : 0.

Retourne

Nemotron3DiarizationOutput ou tuple(torch.Tensor)

Un Nemotron3DiarizationOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (Nemotron3DiarizationConfig) et des entrées.

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

  • logits (torch.Tensor de forme (batch_size, num_frames, config.head_config.num_speakers)) — Logits d'activité des locuteurs par image, à la fréquence des images du spectrogramme. logits.sigmoid() donne la probabilité que chaque locuteur soit actif dans chaque image ; les locuteurs sont ordonnés selon leur première apparition dans l'audio.
  • hidden_states (tuple[torch.Tensor, ...], facultatif, renvoyé lorsque output_hidden_states=True) — États cachés de l’encodeur pour chaque bloc, dans l’ordre des blocs : l’encodeur s’exécute une fois par bloc, le tuple contient donc config.audio_config.num_hidden_layers + 1 tenseurs par bloc. Leur longueur de séquence est celle du bloc, cadres de cache et d’anticipation inclus.
  • attentions (tuple[torch.Tensor, ...], facultatif, renvoyé lorsque output_attentions=True) — Poids d'attention de l'encodeur pour chaque bloc, dans l'ordre des blocs, config.audio_config.num_hidden_layers tenseurs par bloc.
  • speaker_cache (Nemotron3DiarizationSpeakerCache, facultatif, renvoyé en mode streaming) — État de streaming mis à jour, à passer au forward du prochain fragment audio des mêmes flux.

Exemple :

>>> from transformers import AutoModelForAudioFrameClassification, AutoProcessor
>>> from transformers.audio_utils import load_audio

>>> model_id = "nvidia/Nemotron-3-Diarization"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map="auto")

>>> sampling_rate = processor.feature_extractor.sampling_rate
>>> audio = load_audio(
...     "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/en-Alice_woman.wav",
...     sampling_rate=sampling_rate,
... )
>>> inputs = processor(audio, sampling_rate=sampling_rate).to(model.device, dtype=model.dtype)
>>> probabilities = model(**inputs).logits.sigmoid()  # (1, num_frames, 8), one frame every 10 ms
Update on GitHub

←MusicGen Melody Nemotron 3.5 ASR→