Hugging Face's logo

Transformers documentation

Nemotron 3.5 Transcribe

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é contribué à Hugging Face Transformers le 2026-10-28.

Nemotron 3.5 Transcribe

FlashAttention SDPA

Aperçu

Nemotron 3.5 Transcribe est un modèle de langage audio pour la transcription multilingue, la transcription avec attribution des locuteurs, la traduction de la parole et la réponse à des questions sur l'audio. Un encodeur de reconnaissance vocale et le modèle Nemotron 3 Diarization lisent le même spectrogramme ; leurs sorties sont projetées dans un modèle de langage Nemotron-H. Une tête de horodatage des mots sur les sorties de l'encodeur fournit les horodatages au niveau du mot.

Utilisation

Transcription

from transformers import AutoModelForMultimodalLM, AutoProcessor


model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(samples + "en-Alice_woman.wav").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True))

Transcription par lots

from transformers import AutoModelForMultimodalLM, AutoProcessor


model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = [samples + "en-Alice_woman.wav", samples + "diarization_example.mp3"]
speaker_attributed_prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)
prompt = [None, speaker_attributed_prompt]

inputs = processor.apply_transcription_request(audio, prompt=prompt).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024)
texts = processor.decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=False)
print([text.replace(processor.tokenizer.pad_token, "") for text in texts])

Transcription attribuée aux locuteurs

from transformers import AutoModelForMultimodalLM, AutoProcessor


model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": prompt},
            {"type": "audio", "path": samples + "diarization_example.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    enable_thinking=False,
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024)
text = processor.decode(outputs[0, inputs.input_ids.shape[1] :], skip_special_tokens=False)
print(text)

extract_speaker_dict() divise la sortie en un dictionnaire par tour de parole :

for turn in processor.extract_speaker_dict(text):
    print(turn)
{'Speaker': 0, 'Content': "To celebrate the release of Nematron three Dierization, we invited ... from NVIDIA."}
{'Speaker': 1, 'Content': "Hi everybody, thanks for having me. I'm Jane, a pocket voice from QTie."}
{'Speaker': 2, 'Content': "Nice to meet you Chris and Jane. I'm Serena, the Queen three Voice."}
...

Horodatage des mots

Nécessite torchaudio et scipy.

from transformers import AutoModelForMultimodalLM, AutoProcessor


model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)

inputs = processor.apply_transcription_request(samples + "diarization_example.mp3", prompt=prompt).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024, return_word_timestamp_logits=True)
texts = processor.decode(outputs.sequences[:, inputs.input_ids.shape[1] :], skip_special_tokens=False)
timestamps = processor.align_word_timestamps(
    texts,
    outputs.word_timestamp_logits,
    inputs.input_features_mask,
    outputs.speaker_logits,
)
print(timestamps[0]["chunks"][:3])

Pour aligner une transcription qui n'a pas été générée :

input_features_mask = inputs.input_features_mask
audio_outputs = model.get_audio_features(inputs.input_features, input_features_mask)
word_timestamp_logits = model.get_word_timestamp_logits(audio_outputs.asr_last_hidden_state, input_features_mask)
timestamps = processor.align_word_timestamps(
    ["<spk:0> To celebrate the ..."],
    word_timestamp_logits,
    input_features_mask,
    audio_outputs.speaker_logits,
)

Nemotron3_5TranscribeConfig

classe transformers.Nemotron3_5TranscribeConfig

< >

( 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: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 131072word_timestamp_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

Paramètres

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone audio.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • audio_token_id (int, facultatif, valeur par défaut 131072) — L’indice du jeton audio utilisé comme espace réservé pour les embeddings audio. Le point de contrôle d’origine l’ajoute après le vocabulaire du modèle de langage, sans ligne d’embedding : il est encodé comme le jeton 0, puis remplacé par l’audio.
  • word_timestamp_config (Union[dict, Nemotron3_5TranscribeWordTimestampConfig], facultatif) — Configuration de l'encodeur et de la tête de timestamp des mots, qui prédisent les pièces du tokenizer d'alignement à partir des états de l'encodeur de reconnaissance vocale.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Nemotron3 5 TranscribeModel. Elle est utilisée pour instancier un modèle Nemotron3 5 Transcribe 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/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

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 Nemotron3_5TranscribeForConditionalGeneration, Nemotron3_5TranscribeConfig

>>> # Initializing a Nemotron3_5Transcribe configuration
>>> configuration = Nemotron3_5TranscribeConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = Nemotron3_5TranscribeForConditionalGeneration(configuration)

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

Nemotron3_5TranscribeAsrAudioConfig

classe transformers.Nemotron3_5TranscribeAsrAudioConfig

< >

( 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 = 1280intermediate_size: int = 5120num_hidden_layers: int = 32num_attention_heads: int = 10num_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 1280) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 5120) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 32) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 10) — 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 seule trame d'encodeur.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Nemotron3 5 TranscribeModel. Elle est utilisée pour instancier un modèle Nemotron3 5 Transcribe 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/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

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 Nemotron3_5TranscribeAsrAudioModel, Nemotron3_5TranscribeAsrAudioConfig

>>> # Initializing a Nemotron3_5TranscribeAsrAudioModel configuration
>>> configuration = Nemotron3_5TranscribeAsrAudioConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = Nemotron3_5TranscribeAsrAudioModel(configuration)

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

Nemotron3_5TranscribeAudioConfig

classe transformers.Nemotron3_5TranscribeAudioConfig

< >

( 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 = Noneasr_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonediarization_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonespeaker_activity_threshold: float = 0.5 )

Paramètres

  • asr_config (Union[dict, Nemotron3_5TranscribeAsrAudioConfig], facultatif) — Configuration de l'encodeur de reconnaissance vocale.
  • diarization_config (Union[dict, Nemotron3DiarizationConfig], facultatif) — Configuration du modèle de diarisation des locuteurs, dont les activités des locuteurs sont ajoutées aux sorties de l’encodeur de reconnaissance vocale.
  • speaker_activity_threshold (float, facultatif, valeur par défaut 0,5) — Un locuteur est actif dans une trame d’encodeur lorsque sa probabilité est supérieure à ce seuil.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Nemotron3 5 TranscribeModel. Elle est utilisée pour instancier un modèle Nemotron3 5 Transcribe 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/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

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 Nemotron3_5TranscribeAudioModel, Nemotron3_5TranscribeAudioConfig

>>> # Initializing a Nemotron3_5TranscribeAudioModel configuration
>>> configuration = Nemotron3_5TranscribeAudioConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = Nemotron3_5TranscribeAudioModel(configuration)

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

Nemotron3_5TranscribeWordTimestampConfig

classe transformers.Nemotron3_5TranscribeWordTimestampConfig

< >

( 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 = 1280intermediate_size: int = 640num_hidden_layers: int = 2num_attention_heads: int = 16num_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.0vocab_size: int = 23863blank_token_id: int = 23862residual_scale: float = 0.1upsampling_factor: int = 2 )

Paramètres

  • hidden_size (int, facultatif, par défaut 1280) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 640) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 2) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — 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.
  • vocab_size (int, facultatif, par défaut 23863) — Nombre de classes de la tête de timestamp des mots : les pièces de son tokenizer d’alignement, puis le blanc.
  • blank_token_id (int, facultatif, valeur par défaut 23862) — Index de la classe vide, après les morceaux du tokeniseur d’alignement.
  • residual_scale (float, facultatif, valeur par défaut 0.1) — Échelle de la sortie du transformeur ajoutée aux états de l'encodeur de reconnaissance vocale avant le classifieur.
  • upsampling_factor (int, facultatif, valeur par défaut 2) — Nombre de trames de tête par trame d’encodeur, obtenu par une convolution transposée avant le transformer : 2 donne des trames de 40 ms à partir des trames d’encodeur de 80 ms.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Nemotron3 5 TranscribeModel. Elle est utilisée pour instancier un modèle Nemotron3 5 Transcribe 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/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

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 Nemotron3_5TranscribeConfig, Nemotron3_5TranscribeWordTimestampConfig

>>> # Initializing a Nemotron3_5TranscribeWordTimestamp configuration
>>> configuration = Nemotron3_5TranscribeWordTimestampConfig()

>>> # Using it as the word timestamp head of the model
>>> model_configuration = Nemotron3_5TranscribeConfig(word_timestamp_config=configuration)

Nemotron3_5TranscribeProcessor

classe transformers.Nemotron3_5TranscribeProcessor

< >

( feature_extractortokenizeralignment_tokenizerchat_template = Noneaudio_token = '<|audio|>'default_transcription_prompt = 'Audio transcription. Language: as spoken. Wording: verbatim, including fillers and repetitions. Formatting: punctuation and capitalization. Output: transcript only.'subsampling_factor = 8 )

Paramètres

  • feature_extractor (feature_extractor_class) — L'extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (tokenizer_class) — Le tokenizer est une entrée obligatoire.
  • alignment_tokenizer (PreTrainedTokenizerFast) — Le vocabulaire de la tête de timestamps de mots : 23 862 pièces BPE SentencePiece, la classe 23 862 de la tête étant le CTC blank. Utilisé uniquement par align_word_timestamps(), enregistré dans le sous-dossier alignment_tokenizer/. Préfixer par un espace pour reproduire les identifiants SentencePiece originaux de n’importe quel texte, y compris un texte commençant par une balise : alignment_tokenizer.encode(" " + text, add_special_tokens=False).
  • chat_template (str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.
  • audio_token (str, facultatif, par défaut "<|audio|>") — Jeton spécial utilisé pour représenter les entrées audio dans le modèle de discussion.
  • default_transcription_prompt (str, facultatif) — Prompt par défaut utilisé par apply_transcription_request().
  • subsampling_factor (int, facultatif, valeur par défaut 8) — Nombre de trames de spectrogramme par jeton audio, reflétant Nemotron3_5TranscribeAsrAudioConfig.subsampling_factor. Le spectrogramme est complété jusqu'à un multiple de cette valeur.

Construit un Nemotron3_5TranscribeProcessor qui encapsule un extracteur de caractéristiques, un tokeniseur et un tokeniseur d’alignement en un seul processeur.

Nemotron3_5TranscribeProcessor offre toutes les fonctionnalités de feature_extractor_class, tokenizer_class et {alignment_tokenizer_class}. Consultez ~feature_extractor_class, ~tokenizer_class et ~{alignment_tokenizer_class} pour plus d’informations.

__call__

< >

( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.nemotron3_5_transcribe.processing_nemotron3_5_transcribe.Nemotron3_5TranscribeProcessorKwargs'> ) → BatchFeature

Paramètres

  • text (Union[str, list[str]]) — 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.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — 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.
  • output_labels (bool, facultatif, par défaut=False) — Indique s'il faut retourner les étiquettes pour l'entraînement.
  • 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

Un dictionnaire contenant le texte tokenisé (input_ids, attention_mask) et les caractéristiques audio (input_features, input_features_mask).

apply_transcription_request

< >

( audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]prompt: str | list[str] | None = None**kwargs: *<class 'transformers.models.nemotron3_5_transcribe.processing_nemotron3_5_transcribe.Nemotron3_5TranscribeProcessorKwargs'> ) → BatchFeature

Paramètres

  • audio (str, list[str], np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — Audio à transcrire. Les chaînes de caractères sont interprétées comme des chemins locaux ou des URL et seront chargées automatiquement par le chargeur de modèle de chat ; les tableaux NumPy et les tenseurs PyTorch sont transmis directement.
  • prompt (str ou list[str], facultatif) — Prompt(s) personnalisé(s) à inclure dans le tour utilisateur. Une liste doit avoir la même longueur que le lot. Lorsque None, chaque échantillon utilise default_transcription_prompt.
  • **kwargs — Arguments supplémentaires transmis à apply_chat_template() (par exemple text_kwargs, audio_kwargs, …). La réflexion est désactivée à moins que enable_thinking=True ne soit passé (le modèle de chat l'active par défaut).

Retourne

BatchFeature

Sorties du processeur prêtes à être transmises à Nemotron3_5TranscribeForConditionalGeneration.generate().

Préparez les entrées pour la reconnaissance automatique de la parole sans écrire manuellement le prompt de transcription par défaut.

apply_chat_template

< >

( conversation: list[dict[str, str]] | list[list[dict[str, str]]]chat_template: str | None = Nonetools: list[dict] | None = Nonedocuments: list[dict[str, str]] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool | str = Falsereturn_assistant_tokens_mask: bool = Falsetokenize: bool = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = 'auto'return_dict: bool = Falseload_audio_from_video: bool = Falseprocessor_kwargs: dict | None = None**kwargs )

Paramètres

  • conversation (Union[list[Dict, [str, str]], list[list[dict[str, str]]]]) — La conversation à formater.
  • chat_template (Optional[str], facultatif) — Le modèle Jinja à utiliser pour formater la conversation. S'il n'est pas fourni, le modèle de discussion du tokeniseur est utilisé.

De manière similaire à la méthode apply_chat_template des tokenizers, cette méthode applique un modèle Jinja aux conversations d'entrée pour les transformer en une seule chaîne tokenizable.

L’entrée est attendue au format suivant, où le contenu de chaque message est une liste composée de texte et, le cas échéant, d’entrées image ou vidéo. Il est également possible de fournir une image, une vidéo, une URL ou un chemin local, qui sera utilisé pour former pixel_values lorsque return_dict=True. En l’absence de cette information, seul le texte formaté, éventuellement tokenisé, sera renvoyé.

conversation = [ { “role”: “user”, “content”: [ {“type”: “image”, “url”: “https://www.ilankelman.org/stopsigns/australia.jpg”}, {“type”: “text”, “text”: “Please describe this image in detail.”}, ], }, ]

extract_speaker_dict

< >

( text: str | list[str] ) → list[dict] for a single text, list[list[dict]] for a batch

Paramètres

  • text (str ou list[str]) — Texte unique ou lot de textes, décodé avec skip_special_tokens=False : les balises de locuteur <spk:N> sont des jetons spéciaux. Tout ce qui suit le jeton de fin de texte est supprimé.

Retourne

list[dict] pour un texte unique, list[list[dict]] pour un lot

un dictionnaire par tour de parole, avec l’index "Speaker" N de sa balise <spk:N> et son "Content". Un texte sans balise est un tour unique avec "Speaker": None, de même que le texte avant la première balise, s’il y en a une.

Découpe une transcription attribuée aux locuteurs en tours de parole, au format de VibeVoiceAsrProcessor.extract_speaker_dict() sans les horodatages, que ce modèle ne prédit pas.

Exemple :

>>> processor.extract_speaker_dict("<spk:0> Hi, how are you? <spk:1> Fine, thanks.<|im_end|>")
[{'Speaker': 0, 'Content': 'Hi, how are you?'}, {'Speaker': 1, 'Content': 'Fine, thanks.'}]

align_word_timestamps

< >

( transcriptions: str | list[str]word_timestamp_logits: torch.Tensorinput_features_mask: torch.Tensorspeaker_logits: torch.Tensor | None = Nonelanguage: str | list[str | None] | None = Nonespeaker_activity_threshold: float = 0.5max_word_duration: float = 1.0max_word_frames: int = 12 ) → dict or list[dict]

Paramètres

  • transcriptions (str ou list[str]) — Texte généré de chaque enregistrement, décodé avec skip_special_tokens=False pour conserver les balises <spk:N>.
  • word_timestamp_logits (torch.Tensor de forme (batch_size, num_frames * upsampling_factor, vocab_size)) — Logits de la tête de timestamp des mots (word_timestamp_logits de generate(..., return_word_timestamp_logits=True) ou model.get_word_timestamp_logits(...)), la dernière classe étant le CTC blank. Leur nombre de frames par frame d’encodeur, le upsampling_factor de la tête, est lu à partir de leur forme.
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque des trames de spectrogramme valides de chaque enregistrement, tel que renvoyé par le processeur : leur nombre définit la durée de l’enregistrement, et donc l’étape temporelle des trames de la tête.
  • speaker_logits (torch.Tensor de forme (batch_size, num_frames * subsampling_factor, num_speakers), facultatif) — Logits du modèle de diarisation (speaker_logits de generate(..., return_word_timestamp_logits=True) ou de get_audio_features). Sans eux, chaque transcription est alignée comme un seul locuteur et aucune diarisation n'est renvoyée.
  • language (str ou list[str | None], facultatif) — Langue des transcriptions, une seule pour toutes ou une par transcription, détectée à partir du script lorsque None : "zh" et "ja" sont alignés caractère par caractère, "th" n’est pas pris en charge.
  • speaker_activity_threshold (float, facultatif, valeur par défaut 0,5) — Probabilité au-delà de laquelle un locuteur de la diarisation est actif.
  • max_word_duration (float, facultatif, valeur par défaut 1.0) — Durée maximale d'un mot aligné, en secondes.
  • max_word_frames (int, facultatif, valeur par défaut 12) — Décalage maximal et durée d'un mot aligné sur un segment de diarisation, en trames encodeur d'au plus 80 ms.

Retourne

dict ou list[dict]

pour l’enregistrement (ou pour chaque enregistrement d’une liste de transcriptions), en tant que les horodatages des mots du pipeline de reconnaissance vocale, "chunks" ({"text", "timestamp", "speaker"} par mot, timestamp = (start, end) en secondes, triés par ordre chronologique ; speaker est le N de la balise du mot, None avant la première balise et 0 dans une transcription sans balises), "diarization" ({"speaker", "timestamp"} segments d’activité de chaque locuteur de la diarisation), "speaker_tag_to_diarization_speaker" (None pour une balise non appariée) et "failed_speakers" (les balises dont les mots n’ont pas pu être alignés, absentes de "chunks").

Chronomètre chaque mot des transcriptions générées et l’attribue à un locuteur : les mots de chaque balise <spk:N> sont alignés par forçage (torchaudio.functional.forced_align) sur les frames de la tête de timestamp des mots où le locuteur de la diarisation associé à la balise est actif, puis ajustés aux segments de diarisation de ce locuteur. Portage de MultiSpeakerSOTWordTimestampAligner de NeMo, avec une recherche exacte là où ce dernier approxime les enregistrements longs.

Exemple :

>>> inputs = processor.apply_transcription_request(audio, prompt=speaker_attributed_prompt).to(model.device)
>>> outputs = model.generate(**inputs, return_word_timestamp_logits=True, max_new_tokens=500)
>>> transcriptions = processor.decode(
...     outputs.sequences[:, inputs.input_ids.shape[1] :], skip_special_tokens=False
... )
>>> timestamps = processor.align_word_timestamps(
...     transcriptions, outputs.word_timestamp_logits, inputs.input_features_mask, outputs.speaker_logits
... )
>>> timestamps[0]["chunks"][0]  # {'text': ..., 'timestamp': (..., ...), 'speaker': 0}

Nemotron3_5TranscribeAsrAudioModel

classe transformers.Nemotron3_5TranscribeAsrAudioModel

< >

( config: Nemotron3_5TranscribeAsrAudioConfig )

Paramètres

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

L'encodeur de reconnaissance vocale Nemotron 3.5 Transcribe : l'encodeur audio de diarisation Nemotron 3 avec les requêtes et les clés de chaque tête d'attention normalisées, et des embeddings de position rotatifs sur une partie de chaque tête.

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

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

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

Nemotron3_5TranscribeAudioModel

classe transformers.Nemotron3_5TranscribeAudioModel

< >

( config: Nemotron3_5TranscribeAudioConfig )

Paramètres

  • config (Nemotron3_5TranscribeAudioConfig) — 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 transcription audio Nemotron 3.5 : un encodeur de reconnaissance vocale et un modèle de diarisation des locuteurs fonctionnent en parallèle sur le même spectrogramme, et les activités des locuteurs sont ajoutées aux sorties de l'encodeur de reconnaissance vocale.

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: Tensorinput_features_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5TranscribeAudioModelOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, feature_sequence_length, num_mel_bins)) — Spectrogramme log-mel, rembourré jusqu'à un multiple de config.subsampling_factor trames. Comme dans l'original, l'audio plus long que config.diarization_config.chunk_length trames d'encodeur est encodé par morceaux avec contexte.
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length), facultatif) — Masque des trames de spectrogramme valides. Le bourrage doit se faire à droite.

Retourne

Nemotron3_5TranscribeAudioModelOutput ou tuple(torch.Tensor)

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

La méthode forward du modèle Nemotron3_5TranscribeAudioModel redéfinit la méthode spéciale __call__.

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

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (num_audio_tokens, text_config.hidden_size), facultatif) — Embeddings audio projetés des trames encodeur valides de chaque enregistrement, dans l’ordre du lot : les embeddings qui remplacent les jetons audio du prompt. Renvoyé par get_audio_features.

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

  • asr_last_hidden_state (torch.Tensor de forme (batch_size, num_frames, audio_config.hidden_size)) — Sortie de l'encodeur de reconnaissance vocale, avant sa normalisation et les embeddings de locuteur : l'entrée de get_word_timestamp_logits().

  • speaker_logits (torch.Tensor de forme (batch_size, feature_sequence_length, audio_config.num_speakers)) — Logits du modèle de diarisation, une trame par trame de spectrogramme.

Nemotron3_5TranscribeWordTimestampModel

classe transformers.Nemotron3_5TranscribeWordTimestampModel

< >

( config: Nemotron3_5TranscribeWordTimestampConfig )

Paramètres

  • config (Nemotron3_5TranscribeWordTimestampConfig) — 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 transformateur de la tête de timestamp des mots de Nemotron 3.5 Transcribe. La classe Nemotron3_5TranscribeForConditionalGeneration.word_timestamp_head classe sa sortie.

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

< >

( inputs_embeds: Tensorattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Paramètres

  • inputs_embeds (torch.Tensor de forme (batch_size, num_frames, hidden_size)) — États de l'encodeur de reconnaissance vocale, avant l'asr_norm du modèle audio et les embeddings de locuteur.
  • attention_mask (torch.Tensor de forme (batch_size, num_frames), facultatif) — Masque des trames encodeur valides.

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

Retourne num_frames * upsampling_factor images.

Nemotron3_5TranscribeModel

classe transformers.Nemotron3_5TranscribeModel

< >

( config: Nemotron3_5TranscribeConfig )

Paramètres

  • config (Nemotron3_5TranscribeConfig) — 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 Nemotron 3.5 Transcribe (encodeur de reconnaissance vocale et modèle de diarisation des locuteurs en parallèle, projecteur linéaire et modèle de langage Nemotron-H), sans tête de modélisation du langage.

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_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5TranscribeModelOutputWithPast or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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).
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage.
  • 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_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

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

Retourne

Nemotron3_5TranscribeModelOutputWithPast ou tuple(torch.Tensor)

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

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

    Si past_key_values est utilisé, seule la dernière hidden-state des séquences de forme (batch_size, 1, hidden_size) est renvoyée.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si config.is_encoder_decoder=True, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

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

  • audio_hidden_states (torch.Tensor, facultatif) — États cachés audio projetés.

get_audio_features

< >

( input_features: Tensorinput_features_mask: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor) — Valeurs flottantes des caractéristiques mel extraites de la forme d’onde vocale brute.
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités rembourrés.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

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

Cette méthode est utilisée pour obtenir les embeddings audio à partir des caractéristiques d'entrée (un spectrogramme log-mel), ce qui implique l'inférence de l'encodeur audio et du projecteur multi-modal.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    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.

get_word_timestamp_hidden_states

< >

( asr_last_hidden_state: Tensorinput_features_mask: Tensor )

Paramètres

  • asr_last_hidden_state (torch.Tensor de forme (batch_size, num_frames, audio_config.hidden_size)) — Sortie de l'encodeur de reconnaissance vocale avant sa normalisation et les embeddings de locuteur, telle que renvoyée par get_audio_features() pour input_features_mask.
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque des trames de spectrogramme valides. Le bourrage doit se faire à droite.

Exécute l'encodeur de timestamps de mots sur les états de l'encodeur de reconnaissance vocale, par lots de l'encodeur : les états que la tête de timestamps de mots classe.

Nemotron3_5TranscribeForConditionalGeneration

classe transformers.Nemotron3_5TranscribeForConditionalGeneration

< >

( config: Nemotron3_5TranscribeConfig )

Paramètres

  • config (Nemotron3_5TranscribeConfig) — 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 Nemotron 3.5 Transcribe (encodeur de reconnaissance vocale et modèle de diarisation des locuteurs en parallèle, projecteur linéaire et modèle de langage Nemotron-H) avec une tête de modélisation du langage.

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_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5TranscribeCausalLMOutputWithPast or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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).
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage.
  • 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_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • 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.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masqué.
  • 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).
  • logits_to_keep (Union[int, torch.Tensor], facultatif, valeur par défaut 0) — Si c'est un int, calcule les logits pour les logits_to_keep derniers jetons. Si 0, calcule les logits pour tous les input_ids (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un torch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

Retourne

Nemotron3_5TranscribeCausalLMOutputWithPast ou tuple(torch.Tensor)

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

La méthode forward de Nemotron3_5TranscribeForConditionalGeneration redéfinit la méthode spéciale __call__.

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

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache.

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

  • audio_hidden_states (torch.Tensor, facultatif) — États cachés de l'encodeur audio après projection.

Exemple :

>>> from transformers import Nemotron3_5TranscribeForConditionalGeneration, AutoProcessor

>>> model_id = "nvidia/audio-flamingo-3-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5TranscribeForConditionalGeneration.from_pretrained(model_id, device_map="auto")

get_audio_features

< >

( input_featuresinput_features_mask**kwargs )

Paramètres

  • input_features (`of shape(batch_size, sequence_length, feature_dim)) -- The tensors corresponding to the input audio features. Audio features can be obtained using feature_extractor_class. See feature_extractor_class.call for details (processor_classusesfeature_extractor_class` for processing audios).
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque des trames de spectrogramme valides. Le bourrage doit se faire à droite.

Exemple :

get_word_timestamp_logits

< >

( asr_last_hidden_state: Tensorinput_features_mask: Tensor )

Paramètres

  • asr_last_hidden_state (torch.Tensor de forme (batch_size, num_frames, audio_config.hidden_size)) — Sortie de l'encodeur de reconnaissance vocale avant sa normalisation et les embeddings de locuteur, telle que renvoyée par get_audio_features() pour input_features_mask.
  • input_features_mask (torch.Tensor de forme (batch_size, feature_sequence_length)) — Masque des trames de spectrogramme valides. Le bourrage doit se faire à droite.

Logits de la tête de timestamp des mots sur les états de l'encodeur de reconnaissance vocale, que align_word_timestamps() convertit en horodatages des mots.

Exemple :

Update on GitHub

←Nemotron 3.5 ASR Nemotron ASR Streaming→