# 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 em streaming e offline, lida com até oito falantes e ordena as saídas dos falantes pela primeira chegada de cada um no áudio de entrada.

O modelo utiliza o Arrival-Order Speaker Cache (AOSC) [1](https://huggingface.co/papers/2507.18446) e a fila FIFO introduzidos para o Streaming Sortformer [1](https://huggingface.co/papers/2507.18446), [2](https://huggingface.co/papers/2409.06656). 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

```python
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 corta de acordo com o `streaming_mode` e adiciona `num_lookahead_frames`, o número de frames de antecipação 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 antecipação, portanto todos os frames restantes são pontuados.

| `streaming_mode`          | Latê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.

```python
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 muda 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 padding à direita não altera os quadros válidos:

```python
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) | float32 | bfloat16 |
| ------------------------------------- | ------- | -------- |
| streaming, por etapa                   | 1.2x    | 4.4x     |
| offline, gravação de 488 s              | 1.3x    | 2.8x     |

## Nemotron3DiarizationConfig[[transformers.Nemotron3DiarizationConfig]]

#### transformers.Nemotron3DiarizationConfig[[transformers.Nemotron3DiarizationConfig]]

```python
transformers.Nemotron3DiarizationConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, audio_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationAudioConfig | dict | None = None, head_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationHeadConfig | dict | None = None, streaming_config: transformers.models.nemotron3_diarization.configuration_nemotron3_diarization.Nemotron3DiarizationStreamingConfig | dict | None = None, chunk_length: int = 340, chunk_right_context: int = 40, chunk_left_context: int = 0, fifo_length: int = 40, speaker_cache_update_period: int = 300, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/configuration_nemotron3_diarization.py#L146)

**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 do falante. O padrão é `Nemotron3DiarizationHeadConfig()`.

streaming_config (`Nemotron3DiarizationStreamingConfig` ou `dict`, *opcional*) : Política de cache de falantes e os tamanhos de 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 do 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 do codificador de retorno que cada bloco retira novamente dos anteriores, inseridos entre os quadros em cache e o bloco. 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 passo à frente.

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](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Nemotron3DiarizationAudioConfig[[transformers.Nemotron3DiarizationAudioConfig]]

#### transformers.Nemotron3DiarizationAudioConfig[[transformers.Nemotron3DiarizationAudioConfig]]

```python
transformers.Nemotron3DiarizationAudioConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 512, intermediate_size: int = 2048, num_hidden_layers: int = 31, num_attention_heads: int = 8, num_key_value_heads: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 5000, initializer_range: float = 0.02, rope_parameters: dict | None = None, attention_dropout: float | int = 0.0, num_mel_bins: int = 128, subsampling_factor: int = 8)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/configuration_nemotron3_diarization.py#L30)

**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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). 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 usado.

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 usado 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](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Nemotron3DiarizationHeadConfig[[transformers.Nemotron3DiarizationHeadConfig]]

#### transformers.Nemotron3DiarizationHeadConfig[[transformers.Nemotron3DiarizationHeadConfig]]

```python
transformers.Nemotron3DiarizationHeadConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 192, num_speakers: int = 8, audio_hidden_size: int = 512, subsampling_factor: int = 8)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/configuration_nemotron3_diarization.py#L71)

**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 upsampler 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 aparição no áudio.

audio_hidden_size (`int`, *opcional*, padrão 512) : Tamanho oculto da saída do codificador do qual a cabeça faz a projeção. 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](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Nemotron3DiarizationStreamingConfig[[transformers.Nemotron3DiarizationStreamingConfig]]

#### transformers.Nemotron3DiarizationStreamingConfig[[transformers.Nemotron3DiarizationStreamingConfig]]

```python
transformers.Nemotron3DiarizationStreamingConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, fifo_length: int = 264, speaker_cache_update_period: int = 222, speaker_cache_length: int = 264, speaker_cache_silence_frames_per_speaker: int = 1, prediction_score_threshold: float = 0.25, latest_frames_score_boost: float = 0.05, strong_boost_rate: float = 0.75, weak_boost_rate: float = 1.5, min_positive_scores_rate: float = 0.5, num_speakers: int = 8, subsampling_factor: int = 8)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/configuration_nemotron3_diarization.py#L97)

**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 do falante 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 no mínimo `(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 dos 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 dado 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 aumento forte na pontuação, para 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 fraco de pontuação, 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](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

#### transformers.Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

```python
transformers.Nemotron3DiarizationAudioModel(config: Nemotron3DiarizationAudioConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L562)

**Parâmetros:**

config ([Nemotron3DiarizationAudioConfig](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Nemotron3DiarizationAudioModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L576)

**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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Consulte `NemotronAsrStreamingFeatureExtractor.__call__()` para detalhes ([Nemotron3DiarizationProcessor](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) usa [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) 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?](../glossary#attention-mask)

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?](../glossary#position-ids)

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) e das entradas.

O método forward do [Nemotron3DiarizationAudioModel](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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) com a 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 a 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 nas cabeças de autoatenção.

## Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

#### transformers.Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

```python
transformers.Nemotron3DiarizationModel(config: Nemotron3DiarizationConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L652)

**Parâmetros:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Nemotron3Diarization sem o classificador de falantes: codifica um único bloco (com seus quadros em cache) e faz o upsample dos quadros do codificador de volta para a taxa de quadros do espectrograma. Ele não mantém nenhum estado de streaming; consulte [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) para o forward em blocos.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Nemotron3DiarizationModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L660)

**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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Consulte `NemotronAsrStreamingFeatureExtractor.__call__()` para detalhes ([Nemotron3DiarizationProcessor](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) usa [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) 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?](../glossary#attention-mask)

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?](../glossary#position-ids)

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) e das entradas.

O método forward do [Nemotron3DiarizationModel](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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) com a 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 a 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 nas cabeças de autoatenção.

## Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

#### transformers.Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

```python
transformers.Nemotron3DiarizationProcessor(feature_extractor, subsampling_factor = 8, streaming_modes = None, streaming_mode = 'low_latency')
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/processing_nemotron3_diarization.py#L40)

**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 quadros do codificador. O processador é a única fonte de verdade para esse conjunto: `set_streaming_mode()` valida com base nele. Os padrões são os modos do cartão do modelo, `"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 `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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) oferece todas as funcionalidades de [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Consulte [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) para mais informações.

#### __call__[[transformers.Nemotron3DiarizationProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, is_streaming: bool = False, is_first_audio_chunk: bool = True, is_last_audio_chunk: bool = False, **kwargs: *<class 'transformers.models.nemotron3_diarization.processing_nemotron3_diarization.Nemotron3DiarizationProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/processing_nemotron3_diarization.py#L71)

**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 amostras 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 bloco de uma sessão de streaming, com `is_first_audio_chunk` e `is_last_audio_chunk` indicando o primeiro e o último bloco, respectivamente. Os tamanhos dos blocos são os de `streaming_mode`, alterados por `set_streaming_mode()`. Todos os blocos, exceto o último, devem 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 o faz (`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` quadros de codificador de antecipação que o modelo pontua apenas na etapa seguinte e com os quais o próximo chunk abre. O último chunk não possui etapa seguinte, portanto todos os seus quadros são pontuados, independentemente da quantidade, e o seu final é preenchido com zeros, da mesma forma que uma passagem de fala completa preenche o final do áudio, para que ele produza os últimos quadros da fala. Deve ser `False` quando `is_streaming=False`.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.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 como está, 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[[transformers.Nemotron3DiarizationSpeakerCache]]

#### transformers.Nemotron3DiarizationSpeakerCache[[transformers.Nemotron3DiarizationSpeakerCache]]

```python
transformers.Nemotron3DiarizationSpeakerCache(config: Nemotron3DiarizationStreamingConfig, fifo_length: int | None = None, speaker_cache_update_period: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L53)

**Parâmetros:**

config (`Nemotron3DiarizationStreamingConfig`) : Política de cache de falantes e tamanhos de FIFO do modo de streaming.

fifo_length (`int`, *opcional*) : Capacidade da fila FIFO dos quadros mais recentes do codificador. O 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 padrão é `config.speaker_cache_update_period`.

Estado de streaming de [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification): o Arrival-Order Speaker Cache e a fila FIFO dos quadros de codificador mais recentes, aos quais cada chunk presta atenção.

#### atualizar[[transformers.Nemotron3DiarizationSpeakerCache.update]]

```python
update(chunk_input_embeds: Tensor, chunk_logits: Tensor, silence_embeds: Tensor, num_chunk_frames: int, mask: typing.Optional[torch.Tensor] = None, num_lookback_frames: int = 0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L138)

**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,)`) : Embedding de silêncio aprendido 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 alimentados 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 quadros de retrocesso entre os quadros em cache e o bloco em `chunk_input_embeds`: quadros do bloco 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[[transformers.Nemotron3DiarizationOutput]]

#### transformers.Nemotron3DiarizationOutput[[transformers.Nemotron3DiarizationOutput]]

```python
transformers.Nemotron3DiarizationOutput(logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, speaker_cache: transformers.models.nemotron3_diarization.modeling_nemotron3_diarization.Nemotron3DiarizationSpeakerCache | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L267)

**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 por sua primeira aparição no áudio.

hidden_states (`tuple[torch.Tensor, ...]`, *opcional*, retornado quando `output_hidden_states=True`) : Estados ocultos do codificador de cada bloco, na ordem dos blocos: o codificador é executado uma vez por bloco, portanto a tupla contém `config.audio_config.num_hidden_layers + 1` tensores por bloco. O comprimento da sequência é o do bloco, incluindo os quadros 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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification).

## Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

#### transformers.Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

```python
transformers.Nemotron3DiarizationForAudioFrameClassification(config: Nemotron3DiarizationConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L694)

**Parâmetros:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo de diarização de falantes Streaming Sortformer: prevê, para cada quadro de espectrograma, a atividade de até `config.head_config.num_speakers` falantes ordenados por 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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Nemotron3DiarizationForAudioFrameClassification.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, speaker_cache: transformers.models.nemotron3_diarization.modeling_nemotron3_diarization.Nemotron3DiarizationSpeakerCache | None = None, num_lookahead_frames: int | None = None, num_lookback_frames: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_diarization/modeling_nemotron3_diarization.py#L702)

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Consulte `NemotronAsrStreamingFeatureExtractor.__call__()` para detalhes ([Nemotron3DiarizationProcessor](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) usa [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) 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?](../glossary#attention-mask)

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 quadros de codificador finais da entrada que são apenas de antecipação (look-ahead). Eles são considerados, mas seus logits não são retornados e eles não entram na fila FIFO, pois abrem o próximo bloco (chunk). [Nemotron3DiarizationProcessor](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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 bloco por passagem (forward): `num_lookahead_frames` ou `num_lookback_frames` fornecidos (um primeiro bloco cria o `speaker_cache`, blocos posteriores o recebem), ou `speaker_cache` fornecido sozinho (o último bloco da sessão, sem antecipação). A entrada, menos seus quadros de retorno (look-back) e antecipação, é um bloco, independentemente do seu comprimento, empurrado como um todo para a fila FIFO dimensionada por `config.streaming_config`. Modo offline, nenhum fornecido: a entrada é uma gravação inteira, dividida pela passagem em blocos de `config.chunk_length` quadros de codificador que usam até `config.chunk_left_context` quadros de retorno dos anteriores e até `config.chunk_right_context` quadros de antecipação 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 de codificador iniciais da entrada que são apenas de retrospectiva, o final do chunk anterior alimentado novamente antes deste, por cima dos quadros de `speaker_cache`. Eles são considerados, mas seus logits não são retornados e eles não entram novamente na fila FIFO. Padrão é 0.

**Retorna:** [Nemotron3DiarizationOutput](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) ou `tuple(torch.Tensor)`

Um [Nemotron3DiarizationOutput](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) e das entradas.

O método forward da [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/pt/model_doc/nemotron3_diarization#transformers.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:

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