Hugging Face's logo

Transformers documentation

Nemotron 3 Diarization

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

Nemotron 3 Diarization

Visão geral

Nemotron 3 Diarization é um modelo de diarização de falantes em streaming com pesos abertos, projetado para determinar “quem falou quando” em áudio do mundo real. Ele suporta inferência tanto em streaming quanto offline, lida com até oito falantes e ordena as saídas dos falantes pela primeira aparição de cada um no áudio de entrada.

O modelo utiliza o Arrival-Order Speaker Cache (AOSC) 1 e a fila FIFO introduzidos para o Streaming Sortformer 1, 2. Um único checkpoint suporta perfis de latência configuráveis, desde um buffer de entrada de 80 ms até um buffer offline de 30,4 s, e resolução de quadro de saída configurável em múltiplos de 10 ms. Com inferência em blocos, a duração máxima do áudio não é limitada.

Uso

Offline

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

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

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

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

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

Streaming

O áudio chega em blocos, e cada chamada de forward processa um bloco: o processador o recorta de acordo com o streaming_mode e adiciona num_lookahead_frames, o número de frames de look-ahead finais que o modelo considera, mas não pontua, pois eles abrem o próximo bloco. O forward retorna o speaker_cache para ser passado à próxima chamada. O último bloco de uma sessão é extraído com is_last_audio_chunk=True: ele não possui look-ahead, portanto todos os frames restantes são pontuados.

streaming_modeLatência¹
"low_latency" (padrão)1.04 s
"very_low_latency"0.64 s
"ultra_low_latency"0.32 s

¹ Áudio a aguardar antes de o modelo executar em um bloco: o bloco mais seu olhar antecipado, excluindo o tempo de computação.

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

model_id = "nvidia/Nemotron-3-Diarization"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map="auto")
processor.set_streaming_mode("low_latency")  # the default, can also be "very_low_latency" and "ultra_low_latency"
print(f"Streaming latency: {processor.streaming_latency_ms} ms")

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


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

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

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


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

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

Fazendo-o rodar

A entrada do codificador de uma etapa de streaming é [speaker cache | FIFO | chunk], cujo comprimento varia conforme o cache e o FIFO se enchem e diminuem: torch.compile recompilaria cerca de cem vezes por sessão. Preencher cada etapa até a maior janela do modo corrige a forma. As posições reiniciam em zero a cada chunk, portanto o preenchimento à direita não altera os quadros válidos:

import torch.nn.functional as F

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


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


encoder.forward = padded_forward

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

O loop de streaming acima é compilado apenas uma vez. O forward offline faz o chunking da mesma forma, de modo que o mesmo wrapper se aplica com config.fifo_length, config.chunk_left_context, config.chunk_length e config.chunk_right_context em max_window.

Aceleração em relação ao eager (A100, tamanho de lote 1)float32bfloat16
streaming, por etapa1.2x4.4x
offline, gravação de 488 s1.3x2.8x

Nemotron3DiarizationConfig

classe transformers.Nemotron3DiarizationConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationAudioConfig | dict | None = Nonehead_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationHeadConfig | dict | None = Nonestreaming_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationStreamingConfig | dict | None = Nonechunk_length: int = 340chunk_right_context: int = 40chunk_left_context: int = 0fifo_length: int = 40speaker_cache_update_period: int = 300initializer_range: float = 0.02 )

Parâmetros

  • audio_config (Nemotron3DiarizationAudioConfig ou dict, opcional) — Configuração do codificador de áudio do transformer. O padrão é Nemotron3DiarizationAudioConfig().
  • head_config (Nemotron3DiarizationHeadConfig ou dict, opcional) — Configuração da cabeça de falante. O padrão é Nemotron3DiarizationHeadConfig().
  • streaming_config (Nemotron3DiarizationStreamingConfig ou dict, opcional) — Política de cache de falantes e os tamanhos FIFO do modo de streaming. O padrão é Nemotron3DiarizationStreamingConfig().
  • chunk_length (int, opcional, padrão 340) — Modo offline: número de quadros do codificador por bloco quando uma gravação inteira é diarizada em uma única passagem. No modo de streaming, o bloco é a entrada de cada passagem.
  • chunk_right_context (int, opcional, padrão 40) — Modo offline: número de quadros de codificador de antecipação que cada bloco obtém dos seguintes. No modo de streaming, a antecipação é num_lookahead_frames de cada passo à frente.
  • chunk_left_context (int, opcional, padrão 0) — Modo offline: número de quadros de encoder de retorno que cada chunk retira novamente dos quadros anteriores, inseridos entre os quadros em cache e o chunk. Assim como o retorno à frente, eles são considerados, mas não pontuados nem enviados para a fila FIFO. No modo de streaming, o retorno é num_lookback_frames de cada forward.
  • fifo_length (int, opcional, padrão 40) — Modo offline: capacidade da fila FIFO dos quadros de codificador mais recentes. O modo de streaming usa streaming_config.fifo_length.
  • speaker_cache_update_period (int, opcional, padrão 300) — Modo offline: número de quadros do codificador movidos da fila FIFO para o cache do falante quando a fila transborda. O modo de streaming usa streaming_config.speaker_cache_update_period.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3DiarizationModel. Ela é usada para instanciar um modelo de Diarização Nemotron3 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/Nemotron-3-Diarization

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.

Nemotron3DiarizationAudioConfig

classe transformers.Nemotron3DiarizationAudioConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 512intermediate_size: int = 2048num_hidden_layers: int = 31num_attention_heads: int = 8num_key_value_heads: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 5000initializer_range: float = 0.02rope_parameters: dict | None = Noneattention_dropout: float | int = 0.0num_mel_bins: int = 128subsampling_factor: int = 8 )

Parâmetros

  • hidden_size (int, opcional, padrão 512) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 2048) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 31) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 8) — 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. O classificador faz o aumento de amostragem de suas saídas pelo mesmo fator, de modo que a atividade do falante é prevista na taxa de quadros do espectrograma.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3DiarizationModel. Ela é usada para instanciar um modelo de Diarização Nemotron3 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/Nemotron-3-Diarization

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.

Nemotron3DiarizationHeadConfig

classe transformers.Nemotron3DiarizationHeadConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 192num_speakers: int = 8audio_hidden_size: int = 512subsampling_factor: int = 8 )

Parâmetros

  • hidden_size (int, opcional, padrão 192) — Tamanho oculto da cabeça do falante: a saída do codificador é projetada para ele, e o amplificador e o classificador o mantêm.
  • num_speakers (int, opcional, padrão 8) — Número máximo de falantes, ou seja, o número de saídas de atividade por quadro. Os falantes são ordenados pela sua primeira ocorrência no áudio.
  • audio_hidden_size (int, opcional, padrão 512) — Tamanho oculto da saída do codificador a partir do qual a cabeça projeta. Deve corresponder a Nemotron3DiarizationAudioConfig.hidden_size.
  • subsampling_factor (int, opcional, padrão 8) — Fator de upsampling da head, de volta para a taxa de quadros do espectrograma. Deve corresponder a Nemotron3DiarizationAudioConfig.subsampling_factor.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3DiarizationModel. Ela é usada para instanciar um modelo de Diarização Nemotron3 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/Nemotron-3-Diarization

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.

Nemotron3DiarizationStreamingConfig

classe transformers.Nemotron3DiarizationStreamingConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonefifo_length: int = 264speaker_cache_update_period: int = 222speaker_cache_length: int = 264speaker_cache_silence_frames_per_speaker: int = 1prediction_score_threshold: float = 0.25latest_frames_score_boost: float = 0.05strong_boost_rate: float = 0.75weak_boost_rate: float = 1.5min_positive_scores_rate: float = 0.5num_speakers: int = 8subsampling_factor: int = 8 )

Parâmetros

  • fifo_length (int, opcional, padrão 264) — Capacidade da fila FIFO dos quadros mais recentes do codificador no modo de streaming (o modo offline usa Nemotron3DiarizationConfig.fifo_length).
  • speaker_cache_update_period (int, opcional, padrão 222) — Número de quadros do codificador movidos da fila FIFO para o cache de falantes quando a fila transborda, no modo de streaming (o modo offline usa Nemotron3DiarizationConfig.speaker_cache_update_period).
  • speaker_cache_length (int, opcional, padrão 264) — Capacidade do Arrival-Order Speaker Cache. Deve ser pelo menos (1 + speaker_cache_silence_frames_per_speaker) * num_speakers.
  • speaker_cache_silence_frames_per_speaker (int, opcional, padrão 1) — Número de slots de cache de falante por falante reservados para o embedding de silêncio aprendido quando o cache é comprimido.
  • prediction_score_threshold (float, opcional, padrão 0.25) — Limite inferior das probabilidades de falantes antes de calcular o logaritmo nas pontuações dos quadros do cache de falantes.
  • latest_frames_score_boost (float, opcional, padrão 0.05) — Bônus de pontuação atribuído aos quadros recém-adicionados ao cache do falante quando ele é comprimido.
  • strong_boost_rate (float, opcional, padrão 0,75) — Fração do orçamento de cache por falante cujos melhores quadros recebem um forte aumento de pontuação, garantindo que cada falante mantenha pelo menos esse número de quadros no cache.
  • weak_boost_rate (float, opcional, padrão 1.5) — Fração do orçamento de cache por falante cujos melhores quadros recebem um reforço de pontuação fraca, o que impede que um único falante domine o cache.
  • min_positive_scores_rate (float, opcional, padrão 0.5) — Fração do orçamento de cache por falante: um falante com pelo menos esse número de quadros com pontuação positiva tem seus quadros não positivos (fala sobreposta) excluídos do cache.
  • num_speakers (int, opcional, padrão 8) — Número de falantes rastreados pelo cache de falantes. Deve corresponder a Nemotron3DiarizationHeadConfig.num_speakers.
  • subsampling_factor (int, opcional, padrão 8) — Número de quadros de probabilidade de falante por quadro do codificador. Deve corresponder a Nemotron3DiarizationAudioConfig.subsampling_factor.

Esta é a classe de configuração para armazenar a configuração de um Nemotron3DiarizationModel. Ela é usada para instanciar um modelo de Diarização Nemotron3 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/Nemotron-3-Diarization

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.

Nemotron3DiarizationAudioModel

classe transformers.Nemotron3DiarizationAudioModel

< >

( config: Nemotron3DiarizationAudioConfig )

Parâmetros

  • config (Nemotron3DiarizationAudioConfig) — 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 diarização Nemotron3 sem processamento adicional, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.

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 NemotronAsrStreamingFeatureExtractor. Consulte NemotronAsrStreamingFeatureExtractor.__call__() para mais detalhes (Nemotron3DiarizationProcessor usa NemotronAsrStreamingFeatureExtractor para processar os á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 (Nemotron3DiarizationConfig) e das entradas.

O método forward do Nemotron3DiarizationAudioModel 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.

Nemotron3DiarizationModel

classe transformers.Nemotron3DiarizationModel

< >

( config: Nemotron3DiarizationConfig )

Parâmetros

  • config (Nemotron3DiarizationConfig) — 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 Nemotron3Diarization sem o classificador de falantes: codifica um bloco (com seus quadros em cache) e aplica upsample nos quadros do codificador de volta para a taxa de quadros do espectrograma. Ele não mantém estado de streaming; consulte Nemotron3DiarizationForAudioFrameClassification para o forward em blocos.

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 NemotronAsrStreamingFeatureExtractor. Consulte NemotronAsrStreamingFeatureExtractor.__call__() para mais detalhes (Nemotron3DiarizationProcessor usa NemotronAsrStreamingFeatureExtractor para processar os á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 (Nemotron3DiarizationConfig) e das entradas.

O método forward do Nemotron3DiarizationModel 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.

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

Nemotron3DiarizationProcessor

classe transformers.Nemotron3DiarizationProcessor

< >

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

Parâmetros

  • feature_extractor (NemotronAsrStreamingFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • subsampling_factor (int, opcional, padrão 8) — Número de quadros mel por quadro do codificador, espelhando Nemotron3DiarizationAudioConfig.subsampling_factor.
  • streaming_modes (dict[str, tuple[int, int]], opcional) — Modos de streaming suportados pelo checkpoint, mapeando o nome para (chunk_length, chunk_right_context) em frames do encoder. O processador é a única fonte de verdade para esse conjunto: set_streaming_mode() valida com base nele. O padrão são os modos do model-card, "low_latency" (9, 4), "very_low_latency" (6, 2) e "ultra_low_latency" (3, 1).
  • streaming_mode (str, opcional, padrão "low_latency") — Modo de streaming das sessões, um dos valores de streaming_modes; altere-o com set_streaming_mode(). O uso offline o ignora.

Constrói um Nemotron3DiarizationProcessor que encapsula um extrator de recursos em um único processador.

Nemotron3DiarizationProcessor oferece todas as funcionalidades de NemotronAsrStreamingFeatureExtractor. Consulte ~NemotronAsrStreamingFeatureExtractor para mais informações.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]sampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool = Trueis_last_audio_chunk: bool = False**kwargs: *<class 'transformers.models.nemotron3_diarization.processing_nemotron3_diarization.Nemotron3DiarizationProcessorKwargs'> ) → BatchFeature

Parâmetros

  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]) — 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 amostragem do áudio.
  • sampling_rate (int, opcional) — A taxa de amostragem do áudio de entrada em Hz. Validada em relação à taxa de amostragem esperada pelo extrator de recursos (16000 Hz) quando fornecida.
  • is_streaming (bool, opcional, padrão False) — Indica se o áudio é um fragmento de uma sessão de streaming, sendo is_first_audio_chunk e is_last_audio_chunk indicadores do primeiro e do último fragmento, respectivamente. Os tamanhos dos fragmentos são os de streaming_mode, alterados por set_streaming_mode(). Todo fragmento, exceto o último, deve conter exatamente num_samples_first_audio_chunk amostras de áudio para o primeiro e num_samples_per_audio_chunk para os subsequentes.
  • is_first_audio_chunk (bool, opcional, padrão True) — Indica se este é o primeiro bloco de uma sessão de streaming. O extrator de recursos centraliza as janelas de análise (center=True) para o primeiro bloco e para uso offline, e não centraliza (center=False) para os blocos subsequentes, de modo que o espectrograma por bloco reproduza, quadro a quadro, uma única passagem de toda a fala. Deve ser True quando is_streaming=False.
  • is_last_audio_chunk (bool, opcional, padrão False) — Indica se este chunk encerra a sessão de streaming. Um chunk de uma sessão termina com chunk_right_context frames do codificador de look-ahead que o modelo pontua apenas na próxima etapa, e com os quais o próximo chunk da sessão começa. O último chunk não possui próxima etapa, portanto todos os seus frames são pontuados, independentemente da quantidade, e o seu final é preenchido com zeros (zero-padded) da mesma forma que uma passagem de fala completa preenche o final do áudio, de modo que ele produza os últimos frames da fala. Deve ser False quando is_streaming=False.
  • 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

as saídas do extrator de recursos, input_features e attention_mask. No modo de streaming, os quadros finais cuja janela de análise ultrapassa um bloco que não é o último são descartados, de modo que input_features contém exatamente os quadros do bloco e pode ser passado ao modelo diretamente, e todos os blocos, exceto o último, também carregam num_lookahead_frames, o número de seus quadros finais de antecipação do codificador, o que coloca o modelo em modo de streaming.

Nemotron3DiarizationSpeakerCache

classe transformers.Nemotron3DiarizationSpeakerCache

< >

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

Parâmetros

  • config (Nemotron3DiarizationStreamingConfig) — Política de cache de falantes e tamanhos da FIFO do modo de streaming.
  • fifo_length (int, opcional) — Capacidade da fila FIFO dos quadros de codificador mais recentes. O valor padrão é config.fifo_length.
  • speaker_cache_update_period (int, opcional) — Número de quadros do codificador movidos da fila FIFO para o cache do falante quando a fila transborda. O valor padrão é config.speaker_cache_update_period.

Estado de streaming de Nemotron3DiarizationForAudioFrameClassification: o Arrival-Order Speaker Cache e a fila FIFO dos quadros de codificador mais recentes, aos quais cada chunk presta atenção.

atualizar

< >

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

Parâmetros

  • chunk_input_embeds (torch.Tensor de forma (batch_size, num_input_frames, hidden_size)) — Entrada do codificador da etapa: os frames em cache retornados por get_embeds, os frames de retrospectiva, o chunk e sua antelucidação.
  • chunk_logits (torch.Tensor de forma (batch_size, num_input_frames * subsampling_factor, num_speakers)) — Logits dos falantes da etapa, usados para pontuar os quadros quando o cache de falantes é comprimido.
  • silence_embeds (torch.Tensor de forma (hidden_size,)) — Incorporação de silêncio aprendida que preenche os slots de silêncio reservados de um cache comprimido.
  • num_chunk_frames (int) — Número de quadros de chunk que seguem os quadros em cache e de look-back em chunk_input_embeds. Apenas esses entram na fila FIFO: os quadros de look-ahead que vêm depois deles são fornecidos novamente na próxima etapa.
  • mask (torch.Tensor de forma (batch_size, num_input_frames), opcional) — Quadros válidos de chunk_input_embeds, cujos quadros de preenchimento recebem probabilidades de falante iguais a zero.
  • num_lookback_frames (int, opcional, padrão 0) — Número de frames de lookback entre os frames em cache e o chunk em chunk_input_embeds: frames do chunk anterior enviados novamente, já empurrados junto com ele.

Envia um bloco processado para a fila FIFO, movendo seus quadros mais antigos para o cache do alto-falante quando ocorre estouro.

Nemotron3DiarizationOutput

classe transformers.Nemotron3DiarizationOutput

< >

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

Parâmetros

  • logits (torch.Tensor de forma (batch_size, num_frames, config.head_config.num_speakers)) — Logits de atividade dos falantes por quadro, na taxa de quadros do espectrograma. logits.sigmoid() fornece a probabilidade de cada falante estar ativo em cada quadro; os falantes são ordenados pela sua primeira aparição no áudio.
  • hidden_states (tuple[torch.Tensor, ...], opcional, retornado quando output_hidden_states=True) — Estados ocultos do codificador de cada chunk, na ordem dos chunks: o codificador é executado uma vez por chunk, portanto a tupla contém config.audio_config.num_hidden_layers + 1 tensores por chunk. O comprimento da sequência é o do chunk, incluindo os frames de cache e de antecipação.
  • attentions (tuple[torch.Tensor, ...], opcional, retornado quando output_attentions=True) — Pesos de atenção do codificador de cada chunk, na ordem dos chunks, config.audio_config.num_hidden_layers tensores por chunk.
  • speaker_cache (Nemotron3DiarizationSpeakerCache, opcional, retornado no modo de streaming) — Estado de streaming atualizado, para ser passado ao forward do próximo trecho de áudio dos mesmos streams.

Saída de Nemotron3DiarizationForAudioFrameClassification.

Nemotron3DiarizationForAudioFrameClassification

classe transformers.Nemotron3DiarizationForAudioFrameClassification

< >

( config: Nemotron3DiarizationConfig )

Parâmetros

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

Modelo de diarização de falantes Sortformer em streaming: prevê, para cada quadro do espectrograma, a atividade de até config.head_config.num_speakers falantes ordenados pela ordem de chegada. O áudio é processado em blocos, em que cada bloco atende a alguns quadros de antecipação e ao Arrival-Order Speaker Cache e à fila FIFO mantidos em um Nemotron3DiarizationSpeakerCache. Uma gravação inteira é dividida em blocos pelo próprio forward (modo offline); um fluxo é alimentado com um bloco por forward (modo streaming).

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: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonespeaker_cache: transformers.models.nemotron3_diarization.modeling_nemotron3_diarization.Nemotron3DiarizationSpeakerCache | None = Nonenum_lookahead_frames: int | None = Nonenum_lookback_frames: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3DiarizationOutput or tuple(torch.Tensor)

Parâmetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim)) — Os tensors correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando NemotronAsrStreamingFeatureExtractor. Consulte NemotronAsrStreamingFeatureExtractor.__call__() para obter detalhes (Nemotron3DiarizationProcessor usa NemotronAsrStreamingFeatureExtractor para processar os á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?

  • speaker_cache (Nemotron3DiarizationSpeakerCache, opcional) — Estado de streaming retornado pelo forward do chunk anterior dos mesmos fluxos de áudio.
  • num_lookahead_frames (int, opcional) — Modo de streaming: número de frames do codificador no final da entrada que são apenas de antecipação (look-ahead). Eles são considerados na atenção, mas seus logits não são retornados e eles não entram na fila FIFO, pois abrem o próximo bloco (chunk). Nemotron3DiarizationProcessor define isso para todos os blocos, exceto o último, de uma sessão.

    Esses argumentos e num_lookback_frames selecionam o modo. Modo de streaming, um chunk por forward: num_lookahead_frames ou num_lookback_frames fornecidos (o primeiro chunk cria o speaker_cache, os chunks subsequentes o recebem), ou speaker_cache fornecido sozinho (o último chunk da sessão, sem look-ahead). A entrada, menos seus frames de look-back e look-ahead, é um chunk, independentemente do seu comprimento, enviado como um todo para a fila FIFO dimensionada por config.streaming_config. Modo offline, nenhum dos dois fornecido: a entrada é uma gravação inteira, dividida pelo forward em chunks de config.chunk_length frames do encoder que utilizam até config.chunk_left_context frames de look-back dos anteriores e até config.chunk_right_context frames de look-ahead dos seguintes, com uma fila FIFO dimensionada por config.fifo_length; nenhum cache é retornado.

  • num_lookback_frames (int, opcional) — Modo de streaming: número de quadros iniciais do codificador da entrada que servem apenas como look-back, ou seja, o final do chunk anterior é alimentado novamente antes deste, além dos quadros de speaker_cache. Eles são considerados na atenção, mas seus logits não são retornados e eles não voltam a entrar na fila FIFO. O valor padrão é 0.

Retorna

Nemotron3DiarizationOutput ou tuple(torch.Tensor)

Um Nemotron3DiarizationOutput 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 (Nemotron3DiarizationConfig) e das entradas.

O método forward da Nemotron3DiarizationForAudioFrameClassification 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.

  • logits (torch.Tensor de forma (batch_size, num_frames, config.head_config.num_speakers)) — Logits de atividade dos falantes por quadro, na taxa de quadros do espectrograma. logits.sigmoid() fornece a probabilidade de cada falante estar ativo em cada quadro; os falantes são ordenados pela sua primeira aparição no áudio.
  • hidden_states (tuple[torch.Tensor, ...], opcional, retornado quando output_hidden_states=True) — Estados ocultos do codificador de cada chunk, na ordem dos chunks: o codificador é executado uma vez por chunk, portanto a tupla contém config.audio_config.num_hidden_layers + 1 tensores por chunk. O comprimento da sequência é o do chunk, incluindo os frames de cache e de antecipação.
  • attentions (tuple[torch.Tensor, ...], opcional, retornado quando output_attentions=True) — Pesos de atenção do codificador de cada chunk, na ordem dos chunks, config.audio_config.num_hidden_layers tensores por chunk.
  • speaker_cache (Nemotron3DiarizationSpeakerCache, opcional, retornado no modo de streaming) — Estado de streaming atualizado, para ser passado ao forward do próximo trecho de áudio dos mesmos streams.

Exemplo:

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

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

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

←MusicGen Melody Nemotron 3.5 ASR→