# Nemotron 3 Diarization

## Ikhtisar

Nemotron 3 Diarization adalah model speaker diarization streaming open-weight yang dirancang untuk menentukan "siapa berbicara kapan" dalam audio dunia nyata. Model ini mendukung inferensi streaming dan offline, menangani hingga delapan pembicara, dan mengurutkan output pembicara berdasarkan kedatangan pertama masing-masing pembicara dalam audio input.

Model ini menggunakan Arrival-Order Speaker Cache (AOSC) [1](https://huggingface.co/papers/2507.18446) dan antrean FIFO yang diperkenalkan untuk Streaming Sortformer [1](https://huggingface.co/papers/2507.18446), [2](https://huggingface.co/papers/2409.06656). Satu checkpoint mendukung profil latensi yang dapat dikonfigurasi, mulai dari buffer input 80 ms hingga buffer bergaya offline 30,4 s, serta resolusi frame output yang dapat dikonfigurasi dalam kelipatan 10 ms. Dengan inferensi chunked, durasi audio maksimum tidak dibatasi.

## Penggunaan

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

Audio tiba per chunk, dan setiap forward mengambil satu chunk: pemroses memotongnya untuk `streaming_mode` dan menambahkan `num_lookahead_frames`, yaitu jumlah frame look-ahead di ekor yang diperhatikan oleh model tetapi tidak diberi skor, karena frame tersebut membuka chunk berikutnya. Forward mengembalikan `speaker_cache` untuk diteruskan ke panggilan berikutnya. Chunk terakhir dari sesi diekstrak dengan `is_last_audio_chunk=True`: chunk ini tidak memiliki look-ahead, sehingga setiap frame yang tersisa diberi skor.

| `streaming_mode`          | Latensi¹ |
| ------------------------- | -------- |
| `"low_latency"` (default) | 1.04 s   |
| `"very_low_latency"`      | 0.64 s   |
| `"ultra_low_latency"`     | 0.32 s   |

¹ Audio yang harus ditunggu sebelum model dijalankan pada sebuah chunk: chunk tersebut beserta look-ahead-nya, tidak termasuk waktu komputasi.

```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}, ...]
```

### Membuatnya berjalan kencang

Input encoder dari langkah streaming adalah `[speaker cache | FIFO | chunk]`, yang panjangnya berubah seiring cache dan FIFO terisi dan menyusut: `torch.compile` akan mengompilasi ulang sekitar seratus kali per sesi. Padding setiap langkah hingga jendela terbesar dari mode memperbaiki bentuk. Posisi dimulai ulang dari nol pada setiap chunk, sehingga right padding tidak mengubah frame yang valid:

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

Loop streaming di atas kemudian dikompilasi sekali. Forward offline melakukan chunking dengan cara yang sama, sehingga wrapper yang sama berlaku dengan `config.fifo_length`, `config.chunk_left_context`, `config.chunk_length` dan `config.chunk_right_context` di dalam `max_window`.

| Percepatan vs eager (A100, ukuran batch 1) | float32 | bfloat16 |
| ------------------------------------- | ------- | -------- |
| streaming, per langkah                   | 1.2x    | 4.4x     |
| offline, rekaman 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)
```

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

**Parameter:**

audio_config (`Nemotron3DiarizationAudioConfig` atau `dict`, *opsional*) : Konfigurasi dari encoder audio transformer. Bawaan adalah `Nemotron3DiarizationAudioConfig()`.

head_config (`Nemotron3DiarizationHeadConfig` atau `dict`, *opsional*) : Konfigurasi dari speaker head. Defaultnya adalah `Nemotron3DiarizationHeadConfig()`.

streaming_config (`Nemotron3DiarizationStreamingConfig` atau `dict`, *opsional*) : Kebijakan speaker-cache, dan ukuran FIFO untuk mode streaming. Defaultnya adalah `Nemotron3DiarizationStreamingConfig()`.

chunk_length (`int`, *opsional*, default 340) : Mode offline: jumlah frame encoder per chunk ketika seluruh rekaman didiarisasi dalam satu forward. Dalam mode streaming, chunk adalah input dari setiap forward.

chunk_right_context (`int`, *opsional*, default 40) : Mode offline: jumlah frame encoder look-ahead yang diambil setiap chunk dari chunk berikutnya. Dalam mode streaming, look-ahead adalah `num_lookahead_frames` dari setiap forward.

chunk_left_context (`int`, *opsional*, default 0) : Mode offline: jumlah frame encoder look-back yang diambil ulang oleh setiap chunk dari chunk sebelumnya, yang dimasukkan di antara frame yang di-cache dan chunk tersebut. Sama seperti look-ahead, frame ini diperhatikan tetapi tidak diberi skor maupun didorong ke antrean FIFO. Dalam mode streaming, look-back adalah `num_lookback_frames` dari setiap forward.

fifo_length (`int`, *opsional*, default 40) : Mode offline: kapasitas antrean FIFO dari frame encoder terbaru. Mode streaming menggunakan `streaming_config.fifo_length`.

speaker_cache_update_period (`int`, *opsional*, default 300) : Mode offline: jumlah frame encoder yang dipindahkan dari antrean FIFO ke cache pembicara saat antrean meluap. Mode streaming menggunakan `streaming_config.speaker_cache_update_period`.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron3DiarizationModel. Kelas ini digunakan untuk membuat instans model Nemotron3 Diarization sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

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

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `512`) : Dimensi dari representasi tersembunyi.

intermediate_size (`int`, *opsional*, defaultnya `2048`) : Dimensi dari representasi MLP.

num_hidden_layers (`int`, *opsional*, defaultnya `31`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

num_key_value_heads (`int`, *opsional*) : Ini adalah jumlah key_value heads yang harus digunakan untuk mengimplementasikan Grouped Query Attention. Jika `num_key_value_heads=num_attention_heads`, model akan menggunakan Multi Head Attention (MHA), jika `num_key_value_heads=1` model akan menggunakan Multi Query Attention (MQA), selain itu GQA yang digunakan. Saat mengonversi checkpoint multi-head menjadi checkpoint GQA, setiap group key dan value head harus dibangun dengan meanpooling semua head asli di dalam grup tersebut. Untuk detail lebih lanjut, lihat [paper ini](https://huggingface.co/papers/2305.13245). Jika tidak ditentukan, akan default ke `num_attention_heads`.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

max_position_embeddings (`int`, *opsional*, defaultnya `5000`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

rope_parameters (`dict`, *opsional*) : Kamus yang berisi parameter konfigurasi untuk embedding RoPE. Kamus ini harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk penskalaan jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

num_mel_bins (`int`, *opsional*, defaultnya `128`) : Jumlah fitur mel yang digunakan per bingkai input. Seharusnya sesuai dengan nilai yang digunakan di kelas `AutoFeatureExtractor`.

subsampling_factor (`int`, *opsional*, default 8) : Jumlah frame spektrogram berurutan yang ditumpuk menjadi satu frame encoder. Klasifikator melakukan upsample pada outputnya dengan faktor yang sama, sehingga aktivitas pembicara diprediksi pada laju frame spektrogram.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron3DiarizationModel. Kelas ini digunakan untuk membuat instans model Nemotron3 Diarization sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

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

**Parameter:**

hidden_size (`int`, *opsional*, default 192) : Ukuran tersembunyi dari kepala pembicara: output encoder diproyeksikan ke ukuran ini, dan upsampler serta klasifikator mempertahankannya.

num_speakers (`int`, *opsional*, default 8) : Jumlah maksimum pembicara, yaitu jumlah output aktivitas per bingkai. Pembicara diurutkan berdasarkan kedatangan pertama mereka di audio.

audio_hidden_size (`int`, *opsional*, default 512) : Ukuran tersembunyi dari output encoder yang diproyeksikan oleh head. Harus cocok dengan `Nemotron3DiarizationAudioConfig.hidden_size`.

subsampling_factor (`int`, *opsional*, default 8) : Faktor upsampling dari head, kembali ke laju frame spektrogram. Harus cocok dengan `Nemotron3DiarizationAudioConfig.subsampling_factor`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron3DiarizationModel. Kelas ini digunakan untuk membuat instans model Nemotron3 Diarization sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

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

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

**Parameter:**

fifo_length (`int`, *opsional*, default 264) : Kapasitas antrean FIFO dari frame encoder terbaru dalam mode streaming (mode offline menggunakan `Nemotron3DiarizationConfig.fifo_length`).

speaker_cache_update_period (`int`, *opsional*, default 222) : Jumlah frame encoder yang dipindahkan dari antrean FIFO ke cache pembicara saat antrean meluap, dalam mode streaming (mode offline menggunakan `Nemotron3DiarizationConfig.speaker_cache_update_period`).

speaker_cache_length (`int`, *opsional*, default 264) : Kapasitas Arrival-Order Speaker Cache. Harus setidaknya `(1 + speaker_cache_silence_frames_per_speaker) * num_speakers`.

speaker_cache_silence_frames_per_speaker (`int`, *opsional*, default 1) : Jumlah slot speaker-cache per speaker yang dialokasikan untuk embedding keheningan yang dipelajari saat cache dikompresi.

prediction_score_threshold (`float`, *opsional*, default 0.25) : Batas bawah (lower clamp) dari probabilitas pembicara sebelum mengambil logaritma pada skor frame speaker-cache.

latest_frames_score_boost (`float`, *opsional*, default 0.05) : Bonus skor yang diberikan ke frame yang baru ditambahkan ke cache pembicara saat cache tersebut dikompresi.

strong_boost_rate (`float`, *opsional*, default 0.75) : Fraksi dari anggaran cache per pembicara yang frame terbaiknya mendapat peningkatan skor kuat, sehingga setiap pembicara mempertahankan setidaknya sejumlah frame tersebut di dalam cache.

weak_boost_rate (`float`, *opsional*, default 1.5) : Fraksi dari anggaran cache per pembicara yang frame terbaiknya mendapat peningkatan skor lemah, yang mencegah satu pembicara mendominasi cache.

min_positive_scores_rate (`float`, *opsional*, default 0.5) : Fraksi dari anggaran cache per pembicara: pembicara yang memiliki setidaknya sejumlah frame dengan skor positif sebanyak itu akan memiliki frame non-positif (bicara tumpang tindih) yang dikecualikan dari cache.

num_speakers (`int`, *opsional*, default 8) : Jumlah pembicara yang dilacak oleh cache pembicara. Harus cocok dengan `Nemotron3DiarizationHeadConfig.num_speakers`.

subsampling_factor (`int`, *opsional*, default 8) : Jumlah frame probabilitas pembicara per frame encoder. Harus cocok dengan `Nemotron3DiarizationAudioConfig.subsampling_factor`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron3DiarizationModel. Kelas ini digunakan untuk membuat instans model Nemotron3 Diarization sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

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

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

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

**Parameter:**

config ([Nemotron3DiarizationAudioConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Nemotron3 Diarization polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

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

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Lihat `NemotronAsrStreamingFeatureExtractor.__call__()` untuk detailnya ([Nemotron3DiarizationProcessor](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) untuk memproses audio).

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

**Mengembalikan:** [BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Nemotron3DiarizationConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) dan input.

Metode forward dari [Nemotron3DiarizationAudioModel](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

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

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

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

**Parameter:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Nemotron3Diarization tanpa pengklasifikasi pembicara: mengodekan satu chunk (dengan frame yang di-cache) dan melakukan upsample frame encoder kembali ke laju frame spektrogram. Model ini tidak menyimpan state streaming, lihat [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) untuk forward yang di-chunk.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

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

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Lihat `NemotronAsrStreamingFeatureExtractor.__call__()` untuk detailnya ([Nemotron3DiarizationProcessor](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) untuk memproses audio).

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

**Mengembalikan:** [BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Nemotron3DiarizationConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) dan input.

Metode forward dari [Nemotron3DiarizationModel](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

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

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

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

**Parameter:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

subsampling_factor (`int`, *opsional*, default 8) : Jumlah frame mel per frame encoder, mencerminkan `Nemotron3DiarizationAudioConfig.subsampling_factor`.

streaming_modes (`dict[str, tuple[int, int]]`, *opsional*) : Mode streaming yang didukung checkpoint, nama ke `(chunk_length, chunk_right_context)` dalam frame encoder. Prosesor adalah sumber kebenaran tunggal untuk set ini: `set_streaming_mode()` memvalidasi terhadapnya. Bawaan adalah mode kartu model, `"low_latency"` (9, 4), `"very_low_latency"` (6, 2) dan `"ultra_low_latency"` (3, 1).

streaming_mode (`str`, *opsional*, defaultnya `"low_latency"`) : Mode streaming dari sesi, salah satu dari `streaming_modes`; ubah dengan `set_streaming_mode()`. Penggunaan offline mengabaikannya.

Membangun Nemotron3DiarizationProcessor yang membungkus feature extractor menjadi satu processor.

[Nemotron3DiarizationProcessor](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) menyediakan semua fungsionalitas dari [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Lihat [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) untuk informasi lebih lanjut.

#### __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'>)
```

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

**Parameter:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

sampling_rate (`int`, *opsional*) : Laju sampling audio input dalam Hz. Divalidasi terhadap laju sampling yang diharapkan oleh feature extractor (16000 Hz) saat diberikan.

is_streaming (`bool`, *opsional*, defaultnya `False`) : Apakah audio tersebut merupakan satu bagian dari sesi streaming, dengan `is_first_audio_chunk` dan `is_last_audio_chunk` yang menandai bagian pertama dan terakhir dari bagian lainnya. Ukuran bagian-bagian tersebut adalah ukuran dari `streaming_mode`, yang diubah dengan `set_streaming_mode()`. Setiap bagian kecuali bagian terakhir harus berisi tepat `num_samples_first_audio_chunk` sampel audio untuk bagian pertama dan `num_samples_per_audio_chunk` untuk bagian-bagian selanjutnya.

is_first_audio_chunk (`bool`, *opsional*, defaultnya `True`) : Apakah ini adalah chunk pertama dari sesi streaming. Feature extractor memusatkan jendela analisis (`center=True`) untuk chunk pertama dan untuk penggunaan offline, dan tidak memusatkannya (`center=False`) untuk chunk berikutnya, sehingga spektrogram per chunk mereproduksi, frame demi frame, satu kali pemrosesan seluruh ucapan. Harus `True` ketika `is_streaming=False`.

is_last_audio_chunk (`bool`, *opsional*, defaultnya `False`) : Apakah chunk ini mengakhiri sesi streaming. Sebuah chunk sesi diakhiri dengan `chunk_right_context` frame encoder look-ahead yang hanya dinilai model pada langkah berikutnya, dan yang menjadi pembuka chunk berikutnya. Chunk terakhir tidak memiliki langkah berikutnya, sehingga setiap frame-nya dinilai, berapa pun jumlahnya, dan akhirnya di-pad dengan nol seperti jalur full-utterance yang mem-pad akhir audio, sehingga menghasilkan frame terakhir dari ucapan. Harus `False` ketika `is_streaming=False`.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature)

output dari feature extractor, `input_features` dan `attention_mask`. Dalam mode streaming, frame-frame di akhir yang jendela analisisnya melewati chunk selain yang terakhir akan dibuang, sehingga `input_features` berisi tepat frame-frame dari chunk tersebut dan dapat langsung diteruskan ke model, dan setiap chunk selain yang terakhir juga membawa `num_lookahead_frames`, yaitu jumlah frame encoder look-ahead di akhirnya, yang menempatkan model dalam mode 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)
```

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

**Parameter:**

config (`Nemotron3DiarizationStreamingConfig`) : Kebijakan speaker-cache, dan ukuran FIFO untuk mode streaming.

fifo_length (`int`, *opsional*) : Kapasitas antrean FIFO dari frame encoder terbaru. Bawaan adalah `config.fifo_length`.

speaker_cache_update_period (`int`, *opsional*) : Jumlah frame encoder yang dipindahkan dari antrean FIFO ke cache pembicara ketika antrean meluap. Bawaan adalah `config.speaker_cache_update_period`.

Status streaming dari [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification): Arrival-Order Speaker Cache dan antrean FIFO dari frame encoder terbaru, yang menjadi perhatian setiap chunk.

#### update[[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)
```

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

**Parameter:**

chunk_input_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_input_frames, hidden_size)`) : Input encoder dari langkah: frame yang di-cache yang dikembalikan oleh `get_embeds`, frame look-back, chunk, dan look-ahead-nya.

chunk_logits (`torch.Tensor` dengan bentuk `(batch_size, num_input_frames * subsampling_factor, num_speakers)`) : Logit pembicara dari langkah tersebut, digunakan untuk menilai frame saat cache pembicara dikompresi.

silence_embeds (`torch.Tensor` dengan bentuk `(hidden_size,)`) : Embedding keheningan yang dipelajari untuk mengisi slot keheningan yang dicadangkan pada cache terkompresi.

num_chunk_frames (`int`) : Jumlah frame chunk yang mengikuti frame cached dan look-back di `chunk_input_embeds`. Hanya frame-frame tersebut yang bergabung ke antrean FIFO: frame look-ahead setelahnya akan diberikan kembali pada langkah berikutnya.

mask (`torch.Tensor` dengan bentuk `(batch_size, num_input_frames)`, *opsional*) : Frame valid dari `chunk_input_embeds`, di mana frame padding diberi probabilitas pembicara nol.

num_lookback_frames (`int`, *opsional*, default 0) : Jumlah frame look-back antara frame yang di-cache dan chunk di `chunk_input_embeds`: frame dari chunk sebelumnya yang dikirim ulang, sudah didorong bersamanya.

Mendorong chunk yang telah diproses ke antrean FIFO, memindahkan frame tertuanya ke cache speaker saat antrean meluap.

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

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

**Parameter:**

logits (`torch.Tensor` dengan bentuk `(batch_size, num_frames, config.head_config.num_speakers)`) : Logit aktivitas pembicara per frame pada laju frame spektrogram. `logits.sigmoid()` memberikan probabilitas bahwa setiap pembicara aktif di setiap frame; pembicara diurutkan berdasarkan kedatangan pertama mereka di audio.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_hidden_states=True`) : Hidden states encoder dari setiap chunk, dalam urutan chunk: encoder berjalan sekali per chunk, sehingga tuple berisi `config.audio_config.num_hidden_layers + 1` tensor per chunk. Panjang urutannya adalah panjang chunk, termasuk frame cache dan look-ahead.

attentions (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_attentions=True`) : Bobot perhatian encoder untuk setiap chunk, dalam urutan chunk, dengan `config.audio_config.num_hidden_layers` tensor per chunk.

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *opsional*, dikembalikan dalam mode streaming) : Status streaming yang diperbarui, untuk diteruskan ke forward dari chunk audio berikutnya dari stream yang sama.

Output dari [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification).

## Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

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

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

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

**Parameter:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model diarization pembicara Streaming Sortformer: memprediksi, untuk setiap frame spektrogram, aktivitas hingga `config.head_config.num_speakers` pembicara yang diurutkan berdasarkan kedatangan pertama. Audio diproses per chunk, di mana setiap chunk memperhatikan beberapa frame look-ahead serta Arrival-Order Speaker Cache dan antrean FIFO yang dibawa dalam [Nemotron3DiarizationSpeakerCache](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationSpeakerCache). Satu rekaman utuh di-chunk oleh forward itu sendiri (mode offline); sebuah stream diberi satu chunk per forward (mode streaming).

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

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

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Lihat `NemotronAsrStreamingFeatureExtractor.__call__()` untuk detailnya ([Nemotron3DiarizationProcessor](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) menggunakan [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) untuk memproses audio).

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *opsional*) : Status streaming yang dikembalikan oleh forward dari chunk sebelumnya dari stream audio yang sama.

num_lookahead_frames (`int`, *opsional*) : Mode streaming: jumlah frame encoder berujung dari input yang hanya bersifat look-ahead. Frame-frame ini diperhatikan, tetapi logits-nya tidak dikembalikan dan tidak masuk ke antrean FIFO, karena mereka membuka chunk berikutnya. [Nemotron3DiarizationProcessor](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) menyetelnya untuk setiap chunk kecuali yang terakhir dalam sebuah sesi. Argumen-argumen ini dan `num_lookback_frames` menentukan mode. Mode streaming, satu chunk per forward: `num_lookahead_frames` atau `num_lookback_frames` diberikan (chunk pertama membuat `speaker_cache`, chunk berikutnya menerimanya), atau `speaker_cache` diberikan saja (chunk terakhir dari sesi, tanpa look-ahead). Input dikurangi frame look-back dan look-ahead-nya menjadi satu chunk, apa pun panjangnya, dan didorong secara utuh ke antrean FIFO yang ukurannya ditentukan oleh `config.streaming_config`. Mode offline, keduanya tidak diberikan: input adalah rekaman utuh, yang dipecah oleh forward menjadi chunk-chunk ber-`config.chunk_length` frame encoder yang mengambil hingga `config.chunk_left_context` frame look-back dari chunk sebelumnya dan hingga `config.chunk_right_context` frame look-ahead dari chunk berikutnya, dengan antrean FIFO yang ukurannya ditentukan oleh `config.fifo_length`; tidak ada cache yang dikembalikan.

num_lookback_frames (`int`, *opsional*) : Mode streaming: jumlah frame encoder awal dari input yang hanya berfungsi sebagai look-back, yaitu akhir dari chunk sebelumnya yang diberikan kembali di depan chunk ini, di atas frame dari `speaker_cache`. Frame-frame ini diperhatikan, tetapi logits-nya tidak dikembalikan dan tidak bergabung kembali ke antrean FIFO. Nilai default adalah 0.

**Mengembalikan:** [Nemotron3DiarizationOutput](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) atau `tuple(torch.Tensor)`

Sebuah [Nemotron3DiarizationOutput](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Nemotron3DiarizationConfig](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) dan input.

Metode forward dari [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/id/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_frames, config.head_config.num_speakers)`) -- Logit aktivitas pembicara per frame pada laju frame spektrogram. `logits.sigmoid()` memberikan probabilitas bahwa setiap pembicara aktif pada setiap frame; pembicara diurutkan berdasarkan kedatangan pertama mereka di audio.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_hidden_states=True`) -- Hidden states encoder dari setiap chunk, dalam urutan chunk: encoder dijalankan sekali per chunk, sehingga tuple berisi `config.audio_config.num_hidden_layers + 1` tensor per chunk. Panjang urutannya adalah panjang chunk, termasuk frame cache dan look-ahead.
- **attentions** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan saat `output_attentions=True`) -- Bobot perhatian encoder untuk setiap chunk, dalam urutan chunk, dengan `config.audio_config.num_hidden_layers` tensor per chunk.
- **speaker_cache** (`Nemotron3DiarizationSpeakerCache`, *opsional*, dikembalikan dalam mode streaming) -- Status streaming yang diperbarui, untuk diteruskan ke forward dari chunk audio berikutnya dari stream yang sama.

Contoh:

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