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.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 28/10/2026.

Nemotron 3.5 Transcribe

FlashAttention SDPA

Visão geral

Nemotron 3.5 Transcribe é um modelo de linguagem de áudio para transcrição multilíngue, transcrição com atribuição de falantes, tradução de fala e resposta a perguntas sobre áudio. Um codificador de reconhecimento de fala e o modelo Nemotron 3 Diarization leem o mesmo espectrograma; suas saídas são projetadas em um modelo de linguagem Nemotron-H. Um cabeçalho de carimbo de tempo por palavra no codificador fornece os horários no nível de palavra.

Uso

Transcrição

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

Transcrição em lote

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

Transcrição atribuída a falantes

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() divide a saída em um dicionário por turno de cada falante:

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."}
...

Carimbos de tempo por palavra

Requer torchaudio e 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])

Para alinhar uma transcrição que não foi gerada:

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 )

Parâmetros

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de áudio.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto.
  • audio_token_id (int, opcional, padrão 131072) — O índice do token de áudio usado como marcador para as incorporações de áudio. O checkpoint original o adiciona ao final do vocabulário do modelo de linguagem, sem uma linha de incorporação: ele é incorporado como o token 0 e, em seguida, substituído pelo áudio.
  • word_timestamp_config (Union[dict, Nemotron3_5TranscribeWordTimestampConfig], opcional) — Configuração do codificador e da cabeça de carimbo de tempo das palavras, que preveem as peças do tokenizador de alinhamento a partir dos estados do codificador de reconhecimento de fala.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3 5 TranscribeModel. Ela é usada para instanciar um modelo Nemotron3 5 Transcribe de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • hidden_size (int, opcional, padrão 1280) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 5120) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 32) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 10) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, padrão 5000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • rope_parameters (dict, opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • num_mel_bins (int, opcional, padrão 128) — Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor utilizado na classe AutoFeatureExtractor.
  • subsampling_factor (int, opcional, padrão 8) — Número de quadros consecutivos do espectrograma empilhados em um único quadro do codificador.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3 5 TranscribeModel. Ela é usada para instanciar um modelo Nemotron3 5 Transcribe de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • asr_config (Union[dict, Nemotron3_5TranscribeAsrAudioConfig], opcional) — Configuração do codificador de reconhecimento de fala.
  • diarization_config (Union[dict, Nemotron3DiarizationConfig], opcional) — Configuração do modelo de diarização de falantes, cujas atividades de falantes são adicionadas às saídas do codificador de reconhecimento de fala.
  • speaker_activity_threshold (float, opcional, padrão 0,5) — Um falante é considerado ativo em um quadro do codificador quando sua probabilidade é superior a esse limite.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3 5 TranscribeModel. Ela é usada para instanciar um modelo Nemotron3 5 Transcribe de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • hidden_size (int, opcional, padrão 1280) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 640) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 2) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, padrão 5000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • rope_parameters (dict, opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • vocab_size (int, opcional, padrão 23863) — Número de classes da cabeça de timestamp de palavras: as peças do seu tokenizer de alinhamento, seguido do blank.
  • blank_token_id (int, opcional, padrão 23862) — Índice da classe em branco, após as peças do tokenizador de alinhamento.
  • residual_scale (float, opcional, padrão 0.1) — Escala da saída do transformer adicionada aos estados do codificador de reconhecimento de fala antes do classificador.
  • upsampling_factor (int, opcional, padrão 2) — Número de quadros de cabeceira por quadro do codificador, gerado por uma convolução transposta antes do transformer: 2 resulta em quadros de 40 ms a partir dos quadros de 80 ms do codificador.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3 5 TranscribeModel. Ela é usada para instanciar um modelo Nemotron3 5 Transcribe de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • feature_extractor (feature_extractor_class) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (tokenizer_class) — O tokenizer é uma entrada obrigatória.
  • alignment_tokenizer (PreTrainedTokenizerFast) — O vocabulário da cabeça de timestamp de palavras: 23.862 peças BPE de SentencePiece, sendo a classe 23.862 da cabeça o CTC blank. Usado apenas por align_word_timestamps(), salvo na subpasta alignment_tokenizer/. Adicione um espaço no início para reproduzir os ids originais do SentencePiece de qualquer texto, incluindo um texto que começa com uma tag: alignment_tokenizer.encode(" " + text, add_special_tokens=False).
  • chat_template (str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
  • audio_token (str, opcional, padrão "<|audio|>") — Token especial usado para representar entradas de áudio no modelo de chat.
  • default_transcription_prompt (str, opcional) — Prompt padrão usado por apply_transcription_request().
  • subsampling_factor (int, opcional, padrão 8) — Número de quadros do espectrograma por token de áudio, espelhando Nemotron3_5TranscribeAsrAudioConfig.subsampling_factor. O espectrograma é preenchido até um múltiplo desse valor.

Constrói um Nemotron3_5TranscribeProcessor que encapsula um extrator de recursos, um tokenizer e um tokenizer de alinhamento em um único processador.

Nemotron3_5TranscribeProcessor oferece todas as funcionalidades de feature_extractor_class, tokenizer_class e {alignment_tokenizer_class}. Consulte ~feature_extractor_class, ~tokenizer_class e ~{alignment_tokenizer_class} para mais informações.

__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

Parâmetros

  • text (Union[str, list[str]]) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.
  • output_labels (bool, opcional, padrão=False) — Se deve retornar rótulos para o treinamento.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Retorna

BatchFeature

Um dicionário com texto tokenizado (input_ids, attention_mask) e recursos de áudio (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

Parâmetros

  • audio (str, list[str], np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — Áudio para transcrever. Strings são interpretadas como caminhos locais ou URLs e serão carregadas automaticamente pelo carregador do modelo de chat; arrays NumPy e tensores PyTorch são encaminhados diretamente.
  • prompt (str ou list[str], opcional) — Prompt(s) personalizado(s) para incluir na vez do usuário. Uma lista deve ter o mesmo comprimento que o lote. Quando None, cada amostra usa default_transcription_prompt.
  • **kwargs — Argumentos de palavra-chave adicionais encaminhados para apply_chat_template() (por exemplo, text_kwargs, audio_kwargs, …). O raciocínio é desativado, a menos que enable_thinking=True seja passado (o modelo de chat o ativa por padrão).

Retorna

BatchFeature

Saídas do Processor prontas para serem passadas para Nemotron3_5TranscribeForConditionalGeneration.generate().

Prepare os dados de entrada para reconhecimento automático de fala sem escrever manualmente o prompt de transcrição padrão.

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 )

Parâmetros

  • conversation (Union[list[Dict, [str, str]], list[list[dict[str, str]]]]) — A conversa a ser formatada.
  • chat_template (Optional[str], opcional) — O modelo Jinja a ser usado para formatar a conversa. Se não for fornecido, o modelo de chat do tokenizer será utilizado.

Assim como o método apply_chat_template em tokenizadores, este método aplica um modelo Jinja às conversas de entrada para convertê-las em uma única string tokenizável.

A entrada é esperada no seguinte formato, em que o conteúdo de cada mensagem é uma lista consistindo de texto e, opcionalmente, entradas de imagem ou vídeo. Também é possível fornecer uma imagem, vídeo, URL ou caminho local, que será usado para formar pixel_values quando return_dict=True. Se não for fornecido, será obtido apenas o texto formatado, opcionalmente o texto tokenizado.

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

Parâmetros

  • text (str ou list[str]) — Texto único ou lote de textos, decodificado com skip_special_tokens=False: as tags de falante <spk:N> são tokens especiais. Tudo a partir do token de fim de texto é descartado.

Retorna

list[dict] para um único texto, list[list[dict]] para um lote

um dicionário por turno de falante, com o índice "Speaker" N da sua tag <spk:N> e seu "Content". Um texto sem tags é um único turno com "Speaker": None, assim como o texto antes da primeira tag, se houver.

Divide uma transcrição com atribuição de falantes em turnos de fala, no formato de VibeVoiceAsrProcessor.extract_speaker_dict(), sem os timestamps, que este modelo não prevê.

Exemplo:

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

Parâmetros

  • transcriptions (str ou list[str]) — Texto gerado de cada gravação, decodificado com skip_special_tokens=False para manter as tags <spk:N>.
  • word_timestamp_logits (torch.Tensor de forma (batch_size, num_frames * upsampling_factor, vocab_size)) — Logits da cabeça de timestamp de palavras (word_timestamp_logits de generate(..., return_word_timestamp_logits=True) ou model.get_word_timestamp_logits(...)), sendo a última classe o CTC blank. O número de frames por frame do encoder, o upsampling_factor da cabeça, é lido a partir da sua forma.
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara dos quadros de espectrograma válidos de cada gravação, conforme retornado pelo processador: sua quantidade define a duração da gravação, e portanto o passo de tempo dos quadros da cabeça.
  • speaker_logits (torch.Tensor de forma (batch_size, num_frames * subsampling_factor, num_speakers), opcional) — Logits do modelo de diarização (speaker_logits de generate(..., return_word_timestamp_logits=True) ou de get_audio_features). Sem eles, cada transcrição é alinhada como um único falante e nenhuma diarização é retornada.
  • language (str ou list[str | None], opcional) — Idioma dos transcritos, um para todos ou um por transcrito, detectado a partir do roteiro quando None: "zh" e "ja" são alinhados caractere por caractere, "th" não é suportado.
  • speaker_activity_threshold (float, opcional, padrão 0,5) — Probabilidade acima da qual um falante da diarização está ativo.
  • max_word_duration (float, opcional, padrão 1.0) — Duração máxima de uma palavra alinhada, em segundos.
  • max_word_frames (int, opcional, padrão 12) — Deslocamento máximo e duração de uma palavra alinhada a um segmento de diarização, em quadros do codificador de no máximo 80 ms.

Retorna

dict ou list[dict]

para a gravação (ou para cada gravação de uma lista de transcrições), como os timestamps das palavras do pipeline de reconhecimento de fala, "chunks" ({"text", "timestamp", "speaker"} por palavra, timestamp = (start, end) em segundos, ordenados por tempo; speaker é o N da tag da palavra, None antes da primeira tag e 0 em uma transcrição sem tags), "diarization" (segmentos de atividade {"speaker", "timestamp"} de cada falante da diarização), "speaker_tag_to_diarization_speaker" (None para uma tag não correspondida) e "failed_speakers" (as tags cujas palavras não puderam ser alinhadas, ausentes de "chunks").

Cada palavra dos transcritos gerados é cronometrada e atribuída a um falante: as palavras de cada tag <spk:N> são alinhadas forçadamente (torchaudio.functional.forced_align) nos frames da cabeça de timestamp de palavra em que o falante da diarização correspondente à tag está ativo, e em seguida ajustadas aos segmentos de diarização desse falante. Port do MultiSpeakerSOTWordTimestampAligner do NeMo, com uma busca exata onde ele aproxima gravações longas.

Exemplo:

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

Parâmetros

  • config (Nemotron3_5TranscribeAsrAudioConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O encoder de reconhecimento de fala Nemotron 3.5 Transcribe: o encoder de áudio Nemotron 3 Diarization com as queries e keys de cada cabeça de atenção normalizadas, e embeddings de posição rotativos em parte de cada cabeça.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

Retorna

BaseModelOutput ou tuple(torch.Tensor)

Um BaseModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Nemotron3_5TranscribeConfig) e das entradas.

O método forward do Nemotron3_5TranscribeAsrAudioModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Nemotron3_5TranscribeAudioModel

classe transformers.Nemotron3_5TranscribeAudioModel

< >

( config: Nemotron3_5TranscribeAudioConfig )

Parâmetros

  • config (Nemotron3_5TranscribeAudioConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo de transcrição de áudio Nemotron 3.5: um codificador de reconhecimento de fala e um modelo de diarização de falantes são executados em paralelo no mesmo espectrograma, e as atividades dos falantes são adicionadas às saídas do codificador de reconhecimento de fala.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_features: Tensorinput_features_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5TranscribeAudioModelOutput or tuple(torch.Tensor)

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, feature_sequence_length, num_mel_bins)) — Espectrograma mel logarítmico, preenchido até um múltiplo de config.subsampling_factor quadros. Assim como no original, áudio mais longo que config.diarization_config.chunk_length quadros do codificador é codificado em blocos com contexto.
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length), opcional) — Máscara dos quadros de espectrograma válidos. O preenchimento (padding) deve estar à direita.

Retorna

Nemotron3_5TranscribeAudioModelOutput ou tuple(torch.Tensor)

Um Nemotron3_5TranscribeAudioModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Nemotron3_5TranscribeConfig) e das entradas.

O método forward do Nemotron3_5TranscribeAudioModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • pooler_output (torch.Tensor de forma (num_audio_tokens, text_config.hidden_size), opcional) — Embebedings de áudio projetados dos frames válidos do codificador de cada gravação, na ordem do lote: os embebedings que substituem os tokens de áudio do prompt. Retornado por get_audio_features.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • asr_last_hidden_state (torch.Tensor de forma (batch_size, num_frames, audio_config.hidden_size)) — Saída do codificador de reconhecimento de fala, antes da sua normalização e dos embeddings de falante: a entrada de get_word_timestamp_logits().

  • speaker_logits (torch.Tensor de forma (batch_size, feature_sequence_length, audio_config.num_speakers)) — Logits do modelo de diarização, um frame por frame do espectrograma.

Nemotron3_5TranscribeWordTimestampModel

classe transformers.Nemotron3_5TranscribeWordTimestampModel

< >

( config: Nemotron3_5TranscribeWordTimestampConfig )

Parâmetros

  • config (Nemotron3_5TranscribeWordTimestampConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O transformer da cabeça de timestamp de palavras do Nemotron 3.5 Transcribe. A classe Nemotron3_5TranscribeForConditionalGeneration.word_timestamp_head classifica sua saída.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • inputs_embeds (torch.Tensor de forma (batch_size, num_frames, hidden_size)) — Estados do codificador de reconhecimento de fala, antes da asr_norm do modelo de áudio e dos embeddings de falante.
  • attention_mask (torch.Tensor de forma (batch_size, num_frames), opcional) — Máscara dos quadros de codificador válidos.

O método forward do Nemotron3_5TranscribeWordTimestampModel sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

Retorna num_frames * upsampling_factor quadros.

Nemotron3_5TranscribeModel

classe transformers.Nemotron3_5TranscribeModel

< >

( config: Nemotron3_5TranscribeConfig )

Parâmetros

  • config (Nemotron3_5TranscribeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Nemotron 3.5 Transcribe (codificador de reconhecimento de fala e modelo de diarização de falantes em paralelo, projetor linear e modelo de linguagem Nemotron-H), sem uma cabeça de modelagem de linguagem.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara para evitar a execução de atenção nos índices de recurso de preenchimento.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

Nemotron3_5TranscribeModelOutputWithPast ou tuple(torch.Tensor)

Um Nemotron3_5TranscribeModelOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Nemotron3_5TranscribeConfig) e das entradas.

O método forward do Nemotron3_5TranscribeModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos de áudio projetados.

get_audio_features

< >

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

Parâmetros

  • input_features (torch.Tensor) — Valores em ponto flutuante das características mel extraídas da forma de onda bruta da fala.
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara para evitar a execução de atenção em índices de recursos preenchidos.

Retorna

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Um BaseModelOutputWithPooling ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Nemotron3_5TranscribeConfig) e das entradas.

Este método é usado para obter os embeddings de áudio a partir dos recursos de entrada (um log mel espectrograma), ou seja, inferindo o codificador de áudio e o projetor multimodal.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

get_word_timestamp_hidden_states

< >

( asr_last_hidden_state: Tensorinput_features_mask: Tensor )

Parâmetros

  • asr_last_hidden_state (torch.Tensor de forma (batch_size, num_frames, audio_config.hidden_size)) — Saída do codificador de reconhecimento de fala antes da normalização e dos embeddings de falante, conforme retornado por get_audio_features() para input_features_mask.
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara dos quadros de espectrograma válidos. O preenchimento (padding) deve estar à direita.

Executa o codificador de carimbo de data/hora das palavras nos estados do codificador de reconhecimento de fala, nos blocos do codificador: os estados que a cabeça de carimbo de data/hora das palavras classifica.

Nemotron3_5TranscribeForConditionalGeneration

classe transformers.Nemotron3_5TranscribeForConditionalGeneration

< >

( config: Nemotron3_5TranscribeConfig )

Parâmetros

  • config (Nemotron3_5TranscribeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Nemotron 3.5 Transcribe (codificador de reconhecimento de fala e modelo de diarização de falantes em paralelo, projetor linear e modelo de linguagem Nemotron-H) com uma cabeça de modelagem de linguagem.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara para evitar a execução de atenção nos índices de recurso de preenchimento.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • logits_to_keep (Union[int, torch.Tensor], opcional, padrão 0) — Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_ids (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um torch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).

Retorna

Nemotron3_5TranscribeCausalLMOutputWithPast ou tuple(torch.Tensor)

Um Nemotron3_5TranscribeCausalLMOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Nemotron3_5TranscribeConfig) e das entradas.

O método forward de Nemotron3_5TranscribeForConditionalGeneration sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache.

  • hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • audio_hidden_states (torch.Tensor, opcional) — Estados ocultos do codificador de áudio após a projeção.

Exemplo:

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

Parâmetros

  • 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 forma (batch_size, feature_sequence_length)) — Máscara dos quadros de espectrograma válidos. O preenchimento (padding) deve estar à direita.

Exemplo:

get_word_timestamp_logits

< >

( asr_last_hidden_state: Tensorinput_features_mask: Tensor )

Parâmetros

  • asr_last_hidden_state (torch.Tensor de forma (batch_size, num_frames, audio_config.hidden_size)) — Saída do codificador de reconhecimento de fala antes da normalização e dos embeddings de falante, conforme retornado por get_audio_features() para input_features_mask.
  • input_features_mask (torch.Tensor de forma (batch_size, feature_sequence_length)) — Máscara dos quadros de espectrograma válidos. O preenchimento (padding) deve estar à direita.

Logits da cabeça de timestamp da palavra nos estados do codificador de reconhecimento de fala, que align_word_timestamps() converte em tempos das palavras.

Exemplo:

Update on GitHub

←Nemotron 3.5 ASR Nemotron ASR Streaming→