# Nemotron 3 Phân tách người nói

## Tổng quan

Nemotron 3 Diarization là một mô hình phân tách người nói (speaker diarization) dạng streaming với trọng số mở, được thiết kế để xác định "ai nói khi nào" trong âm thanh thực tế. Mô hình hỗ trợ cả suy luận streaming và offline, xử lý tối đa tám người nói, và sắp xếp đầu ra của từng người nói theo thời điểm xuất hiện đầu tiên của họ trong âm thanh đầu vào.

Mô hình sử dụng Arrival-Order Speaker Cache (AOSC) [1](https://huggingface.co/papers/2507.18446) và hàng đợi FIFO được giới thiệu cho Streaming Sortformer [1](https://huggingface.co/papers/2507.18446), [2](https://huggingface.co/papers/2409.06656). Một checkpoint duy nhất hỗ trợ các hồ sơ độ trễ có thể cấu hình, từ bộ đệm đầu vào 80 ms đến bộ đệm kiểu ngoại tuyến 30,4 giây, và độ phân giải khung đầu ra có thể cấu hình theo bội số của 10 ms. Với suy luận theo chunk, thời lượng âm thanh tối đa không bị giới hạn.

## Cách sử dụng

### Ngoại tuyến

```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 được truyền đến theo từng khối (chunk), và mỗi lần forward xử lý một khối: bộ xử lý cắt khối đó theo `streaming_mode` của nó và thêm `num_lookahead_frames`, tức là số khung nhìn trước (look-ahead) ở phần cuối mà mô hình chú ý đến nhưng không chấm điểm, vì chúng mở ra khối tiếp theo. Hàm forward trả về `speaker_cache` để truyền cho lần gọi tiếp theo. Khối cuối cùng của một phiên được trích xuất bằng `is_last_audio_chunk=True`: nó không có khung nhìn trước, nên mọi khung còn lại đều được chấm điểm.

| `streaming_mode`          | Độ trễ¹ |
| ------------------------- | -------- |
| `"low_latency"` (mặc định) | 1.04 s   |
| `"very_low_latency"`      | 0.64 s   |
| `"ultra_low_latency"`     | 0.32 s   |

¹ Âm thanh cần chờ trước khi mô hình chạy trên một khối: bao gồm khối đó cùng phần nhìn trước của nó, không tính thời gian tính toán.

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

### Tối ưu để chạy nhanh

Đầu vào của bộ mã hóa trong một bước streaming là `[speaker cache | FIFO | chunk]`, trong đó độ dài thay đổi khi cache và FIFO được lấp đầy và thu nhỏ: `torch.compile` sẽ biên dịch lại khoảng một trăm lần mỗi phiên. Việc đệm (padding) mọi bước lên cửa sổ lớn nhất của chế độ sẽ cố định hình dạng. Vị trí được khởi động lại từ zero ở mỗi chunk, do đó việc đệm bên phải không làm thay đổi các khung hợp lệ:

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

Vòng lặp streaming ở trên sau đó chỉ được biên dịch một lần. Phần forward offline chia chunk theo cách tương tự, do đó cùng một wrapper áp dụng với `config.fifo_length`, `config.chunk_left_context`, `config.chunk_length` và `config.chunk_right_context` trong `max_window`.

| Tốc độ tăng so với eager (A100, kích thước lô 1) | float32 | bfloat16 |
| ------------------------------------- | ------- | -------- |
| streaming, từng bước                   | 1.2x    | 4.4x     |
| offline, 488 s ghi âm              | 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)
```

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

**Tham số:**

audio_config (`Nemotron3DiarizationAudioConfig` hoặc `dict`, *tùy chọn*) : Cấu hình của bộ mã hóa âm thanh transformer. Mặc định là `Nemotron3DiarizationAudioConfig()`.

head_config (`Nemotron3DiarizationHeadConfig` hoặc `dict`, *tùy chọn*) : Cấu hình của đầu người nói. Mặc định là `Nemotron3DiarizationHeadConfig()`.

streaming_config (`Nemotron3DiarizationStreamingConfig` hoặc `dict`, *tùy chọn*) : Chính sách bộ nhớ đệm người nói và kích thước FIFO của chế độ streaming. Mặc định là `Nemotron3DiarizationStreamingConfig()`.

chunk_length (`int`, *optional*, mặc định là 340) : Chế độ offline: số khung encoder mỗi chunk khi toàn bộ bản ghi được phân tách người nói trong một lần forward. Trong chế độ streaming, chunk là đầu vào của mỗi lần forward.

chunk_right_context (`int`, *tuỳ chọn*, mặc định là 40) : Chế độ ngoại tuyến: số khung mã hóa nhìn trước mà mỗi khối lấy từ các khối tiếp theo. Trong chế độ phát trực tiếp, số khung nhìn trước là `num_lookahead_frames` của mỗi bước tiến.

chunk_left_context (`int`, *optional*, mặc định là 0) : Chế độ offline: số lượng khung encoder nhìn lại mà mỗi chunk lấy lại từ các khung trước đó, được đưa vào giữa các khung đã lưu cache và chunk. Giống như nhìn trước, chúng được chú ý đến nhưng không được chấm điểm cũng như không được đẩy vào hàng đợi FIFO. Trong chế độ streaming, nhìn lại là `num_lookback_frames` của mỗi bước tiến.

fifo_length (`int`, *tuỳ chọn*, mặc định là 40) : Chế độ ngoại tuyến: dung lượng của hàng đợi FIFO cho các khung mã hóa gần nhất. Chế độ phát trực tiếp sử dụng `streaming_config.fifo_length`.

speaker_cache_update_period (`int`, *tuỳ chọn*, mặc định là 300) : Chế độ ngoại tuyến: số khung mã hóa được chuyển từ hàng đợi FIFO sang bộ nhớ đệm của người nói khi hàng đợi tràn. Chế độ phát trực tiếp sử dụng `streaming_config.speaker_cache_update_period`.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

Đây là lớp cấu hình để lưu trữ cấu hình của một Nemotron3DiarizationModel. Nó được sử dụng để khởi tạo một mô hình Nemotron 3 Diarization theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `512`) : Kích thước của các biểu diễn ẩn.

intermediate_size (`int`, *tuỳ chọn*, mặc định là `2048`) : Kích thước của các biểu diễn MLP.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `31`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `8`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

num_key_value_heads (`int`, *optional*) : Đây là số lượng key_value heads cần được sử dụng để triển khai Grouped Query Attention. Nếu `num_key_value_heads=num_attention_heads`, mô hình sẽ sử dụng Multi Head Attention (MHA), nếu `num_key_value_heads=1` mô hình sẽ sử dụng Multi Query Attention (MQA), ngược lại GQA sẽ được sử dụng. Khi chuyển đổi một checkpoint multi-head sang checkpoint GQA, mỗi nhóm key và value head nên được xây dựng bằng cách meanpooling tất cả các head gốc trong nhóm đó. Để biết thêm chi tiết, hãy xem [bài báo này](https://huggingface.co/papers/2305.13245). Nếu không được chỉ định, giá trị mặc định sẽ là `num_attention_heads`.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `5000`) : Độ dài tối đa của chuỗi mà mô hình này có thể được sử dụng.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

rope_parameters (`dict`, *tùy chọn*) : Từ điển chứa các tham số cấu hình cho các embedding RoPE. Từ điển phải chứa một giá trị cho `rope_theta` và tùy chọn các tham số được sử dụng để mở rộng trong trường hợp bạn muốn sử dụng RoPE với `max_position_embeddings` dài hơn.

attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

num_mel_bins (`int`, *tuỳ chọn*, mặc định là `128`) : Số lượng đặc trưng mel được sử dụng cho mỗi khung đầu vào. Cần khớp với giá trị được dùng trong lớp `AutoFeatureExtractor`.

subsampling_factor (`int`, *optional*, mặc định là 8) : Số lượng khung spectrogram liên tiếp được xếp chồng vào một khung encoder. Bộ phân loại sẽ tăng mẫu đầu ra của nó với cùng hệ số, do đó hoạt động của người nói được dự đoán ở tốc độ khung spectrogram.

Đây là lớp cấu hình để lưu trữ cấu hình của một Nemotron3DiarizationModel. Nó được sử dụng để khởi tạo một mô hình Nemotron 3 Diarization theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

hidden_size (`int`, *optional*, mặc định là 192) : Kích thước ẩn của đầu speaker: đầu ra của encoder được chiếu lên kích thước này, và upsampler cùng bộ phân loại giữ nguyên kích thước đó.

num_speakers (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng người nói tối đa, tức là số lượng đầu ra hoạt động cho từng khung hình. Các người nói được sắp xếp theo thứ tự xuất hiện đầu tiên trong âm thanh.

audio_hidden_size (`int`, *optional*, mặc định là 512) : Kích thước ẩn của đầu ra encoder mà head chiếu từ đó. Phải khớp với `Nemotron3DiarizationAudioConfig.hidden_size`.

subsampling_factor (`int`, *optional*, mặc định là 8) : Hệ số mở rộng (upsampling) của head, đưa về tần số khung của spectrogram. Phải khớp với `Nemotron3DiarizationAudioConfig.subsampling_factor`.

Đây là lớp cấu hình để lưu trữ cấu hình của một Nemotron3DiarizationModel. Nó được sử dụng để khởi tạo một mô hình Nemotron 3 Diarization theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

fifo_length (`int`, *tuỳ chọn*, mặc định là 264) : Dung lượng của hàng đợi FIFO chứa các khung mã hóa gần nhất trong chế độ streaming (chế độ offline sử dụng `Nemotron3DiarizationConfig.fifo_length`).

speaker_cache_update_period (`int`, *tuỳ chọn*, mặc định là 222) : Số khung encoder được chuyển từ hàng đợi FIFO sang bộ nhớ đệm người nói khi hàng đợi tràn, trong chế độ streaming (chế độ offline sử dụng `Nemotron3DiarizationConfig.speaker_cache_update_period`).

speaker_cache_length (`int`, *tuỳ chọn*, mặc định là 264) : Dung lượng của Arrival-Order Speaker Cache. Phải ít nhất là `(1 + speaker_cache_silence_frames_per_speaker) * num_speakers`.

speaker_cache_silence_frames_per_speaker (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng khe cache dành cho mỗi người nói được dành riêng cho embedding im lặng đã học khi cache được nén.

prediction_score_threshold (`float`, *optional*, mặc định là 0.25) : Ngưỡng kẹp dưới của xác suất người nói trước khi lấy log của chúng trong điểm khung bộ nhớ đệm người nói.

latest_frames_score_boost (`float`, *tuỳ chọn*, mặc định là 0.05) : Điểm thưởng được cấp cho các khung hình mới được thêm vào bộ nhớ đệm của người nói khi bộ nhớ đệm đó bị nén.

strong_boost_rate (`float`, *optional*, mặc định là 0.75) : Tỷ lệ ngân sách cache cho mỗi người nói mà các khung hình tốt nhất sẽ nhận được mức tăng điểm mạnh, đảm bảo mỗi người nói giữ lại ít nhất số khung hình đó trong cache.

weak_boost_rate (`float`, *optional*, mặc định là 1.5) : Tỷ lệ ngân sách cache cho mỗi người nói mà các khung hình tốt nhất trong đó nhận được mức tăng điểm yếu, nhằm ngăn một người nói chiếm ưu thế trong cache.

min_positive_scores_rate (`float`, *optional*, mặc định là 0.5) : Tỷ lệ của ngân sách cache cho mỗi người nói: người nói có ít nhất số khung hình được chấm điểm dương bằng hoặc lớn hơn tỷ lệ này sẽ có các khung hình không dương (lời nói chồng chéo) bị loại khỏi cache.

num_speakers (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng người nói được theo dõi bởi bộ nhớ đệm người nói. Phải khớp với `Nemotron3DiarizationHeadConfig.num_speakers`.

subsampling_factor (`int`, *optional*, mặc định là 8) : Số khung xác suất người nói trên mỗi khung encoder. Phải khớp với `Nemotron3DiarizationAudioConfig.subsampling_factor`.

Đây là lớp cấu hình để lưu trữ cấu hình của một Nemotron3DiarizationModel. Nó được sử dụng để khởi tạo một mô hình Nemotron 3 Diarization theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

## Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

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

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

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

**Tham số:**

config ([Nemotron3DiarizationAudioConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Phân tách người nói Nemotron3 cơ bản, xuất ra các trạng thái ẩn thô mà không có bất kỳ đầu (head) cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Xem `NemotronAsrStreamingFeatureExtractor.__call__()` để biết chi tiết ([Nemotron3DiarizationProcessor](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) để xử lý âm thanh).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

position_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

**Trả về:** [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([Nemotron3DiarizationConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) và đầu vào.

Phương thức forward của [Nemotron3DiarizationAudioModel](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

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

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

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

**Tham số:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Nemotron3Diarization không có bộ phân loại người nói: mã hóa một khối (cùng với các khung đã được lưu bộ) và tăng mẫu các khung mã hóa trở lại tần số khung của phổ âm. Mô hình này không giữ trạng thái phát trực tiếp, xem [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) để biết về tiến trình phía trước theo khối.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Xem `NemotronAsrStreamingFeatureExtractor.__call__()` để biết chi tiết ([Nemotron3DiarizationProcessor](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) để xử lý âm thanh).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

position_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

**Trả về:** [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([Nemotron3DiarizationConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) và đầu vào.

Phương thức forward của [Nemotron3DiarizationModel](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationModel) ghi đè phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

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

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

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

**Tham số:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

subsampling_factor (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng khung mel trên mỗi khung encoder, phản ánh `Nemotron3DiarizationAudioConfig.subsampling_factor`.

streaming_modes (`dict[str, tuple[int, int]]`, *tùy chọn*) : Các chế độ streaming mà checkpoint hỗ trợ, ánh xạ tên sang `(chunk_length, chunk_right_context)` theo khung encoder. Bộ xử lý là nguồn sự thật duy nhất cho tập hợp này: `set_streaming_mode()` sẽ kiểm tra hợp lệ dựa trên tập hợp đó. Mặc định là các chế độ trong model-card, `"low_latency"` (9, 4), `"very_low_latency"` (6, 2) và `"ultra_low_latency"` (3, 1).

streaming_mode (`str`, *tùy chọn*, mặc định là `"low_latency"`) : Chế độ streaming của các phiên, một trong số `streaming_modes`; thay đổi bằng `set_streaming_mode()`. Việc sử dụng ngoại tuyến sẽ bỏ qua tham số này.

Tạo một Nemotron3DiarizationProcessor đóng gói một bộ trích xuất đặc trưng thành một bộ xử lý duy nhất.

[Nemotron3DiarizationProcessor](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) cung cấp đầy đủ các chức năng của [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Xem [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) để biết thêm thông tin.

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

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

**Tham số:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh.

sampling_rate (`int`, *optional*) : Tần số lấy mẫu của âm thanh đầu vào, tính bằng Hz. Được kiểm tra đối chiếu với tần số lấy mẫu mong đợi của bộ trích xuất đặc trưng (16000 Hz) khi được cung cấp.

is_streaming (`bool`, *tuỳ chọn*, mặc định là `False`) : Xác định xem âm thanh có phải là một khối của phiên streaming hay không, trong đó `is_first_audio_chunk` và `is_last_audio_chunk` dùng để phân biệt khối đầu tiên và khối cuối cùng với các khối còn lại. Kích thước của các khối là kích thước của `streaming_mode`, được thay đổi bằng `set_streaming_mode()`. Mọi khối ngoại trừ khối cuối cùng phải chứa chính xác `num_samples_first_audio_chunk` mẫu âm thanh cho khối đầu tiên và `num_samples_per_audio_chunk` cho các khối sau đó.

is_first_audio_chunk (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem đây có phải là khối đầu tiên của một phiên streaming hay không. Bộ trích xuất đặc tính sẽ căn giữa các cửa sổ phân tích (`center=True`) cho khối đầu tiên và cho việc sử dụng ngoại tuyến, và không làm vậy (`center=False`) cho các khối sau, để đảm bảo phổ âm (spectrogram) của từng khối tái tạo lại, từng khung một, kết quả của một lượt xử lý toàn bộ câu nói. Phải là `True` khi `is_streaming=False`.

is_last_audio_chunk (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem khối này có kết thúc phiên streaming hay không. Một khối của phiên kết thúc bằng các khung encoder look-ahead `chunk_right_context` mà mô hình chỉ chấm điểm ở bước tiếp theo, và khối tiếp theo sẽ mở đầu bằng các khung đó. Khối cuối cùng không có bước tiếp theo, do đó mọi khung của nó đều được chấm điểm, bất kể số lượng, và phần cuối của nó được đệm bằng số 0 giống như cách một lượt xử lý toàn bộ câu nói đệm phần cuối của âm thanh, để tạo ra các khung cuối cùng của câu nói. Phải là `False` khi `is_streaming=False`.

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

**Trả về:** [BatchFeature](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.BatchFeature)

các đầu ra của bộ trích xuất đặc trưng, `input_features` và `attention_mask`. Ở chế độ streaming, các khung cuối mà cửa sổ phân tích của chúng vượt qua một chunk không phải chunk cuối sẽ bị loại bỏ, do đó `input_features` chỉ chứa đúng các khung của chunk đó và có thể được truyền trực tiếp vào mô hình, và mọi chunk trừ chunk cuối đều mang theo `num_lookahead_frames`, số lượng khung encoder look-ahead ở phần cuối của chunk, điều này đặt mô hình vào chế độ 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)
```

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

**Tham số:**

config (`Nemotron3DiarizationStreamingConfig`) : Chính sách bộ nhớ đệm người nói và kích thước FIFO của chế độ streaming.

fifo_length (`int`, *optional*) : Dung lượng của hàng đợi FIFO cho các khung encoder gần nhất. Mặc định là `config.fifo_length`.

speaker_cache_update_period (`int`, *optional*) : Số lượng khung mã hóa được chuyển từ hàng đợi FIFO sang bộ nhớ đệm của người nói khi hàng đợi tràn. Mặc định là `config.speaker_cache_update_period`.

Trạng thái streaming của [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification): bộ nhớ đệm người nói theo thứ tự đến (Arrival-Order Speaker Cache) và hàng đợi FIFO của các khung encoder gần nhất, mà mọi chunk đều tham chiếu đến.

#### cập nhật[[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)
```

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

**Tham số:**

chunk_input_embeds (`torch.Tensor` có hình dạng `(batch_size, num_input_frames, hidden_size)`) : Đầu vào của bộ mã hóa cho bước này: các khung đã được lưu trữ trả về bởi `get_embeds`, các khung nhìn lại, khối dữ liệu và phần nhìn trước của nó.

chunk_logits (`torch.Tensor` có hình dạng `(batch_size, num_input_frames * subsampling_factor, num_speakers)`) : Logits của người nói tại bước này, được sử dụng để chấm điểm các khung hình khi bộ nhớ đệm người nói bị nén.

silence_embeds (`torch.Tensor` có hình dạng `(hidden_size,)`) : Nhúng im lặng đã học, dùng để lấp đầy các khe im lặng được dành sẵn trong bộ nhớ đệm đã nén.

num_chunk_frames (`int`) : Số lượng khung chunk tiếp theo sau các khung được cache và look-back trong `chunk_input_embeds`. Chỉ những khung này mới tham gia hàng đợi FIFO: các khung look-ahead sau chúng sẽ được nạp lại ở bước tiếp theo.

mask (`torch.Tensor` có shape `(batch_size, num_input_frames)`, *tùy chọn*) : Các khung hình hợp lệ của `chunk_input_embeds`, trong đó các khung hình padding được gán xác suất người nói bằng không.

num_lookback_frames (`int`, *optional*, mặc định là 0) : Số lượng khung nhìn lại giữa các khung được lưu đệm và khối trong `chunk_input_embeds`: các khung của khối trước đó được đưa lại, đã được đẩy cùng với nó.

Đẩy một khối đã xử lý vào hàng đợi FIFO, di chuyển các khung hình cũ nhất của nó vào bộ nhớ đệm của loa khi hàng đợi tràn.

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

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

**Tham số:**

logits (`torch.Tensor` có shape `(batch_size, num_frames, config.head_config.num_speakers)`) : Logits hoạt động của từng người nói theo từng frame, ở tốc độ frame của spectrogram. `logits.sigmoid()` cho xác suất để mỗi người nói đang hoạt động trong mỗi frame; các người nói được sắp xếp theo thứ tự xuất hiện đầu tiên trong âm thanh.

hidden_states (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Trạng thái ẩn của encoder cho từng chunk, theo thứ tự chunk: encoder chạy một lần cho mỗi chunk, nên tuple chứa `config.audio_config.num_hidden_layers + 1` tensor cho mỗi chunk. Độ dài chuỗi của chúng là độ dài của chunk, bao gồm cả các khung cache và look-ahead.

attentions (`tuple[torch.Tensor, ...]`, *optional*, được trả về khi `output_attentions=True`) : Trọng số attention của encoder cho mọi chunk, theo thứ tự chunk, mỗi chunk có `config.audio_config.num_hidden_layers` tensor.

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *tùy chọn*, được trả về ở chế độ streaming) : Trạng thái streaming đã cập nhật, để truyền vào forward của chunk âm thanh tiếp theo của cùng các luồng.

Đầu ra của [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification).

## Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

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

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

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

**Tham số:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình phân tách giọng nói Streaming Sortformer: dự đoán, cho mỗi khung spectrogram, hoạt động của tối đa `config.head_config.num_speakers` người nói được sắp xếp theo thứ tự xuất hiện đầu tiên. Âm thanh được xử lý theo từng khối, mỗi khối chú ý đến một vài khung nhìn trước và đến bộ nhớ đệm người nói theo thứ tự đến cùng hàng đợi FIFO được giữ trong [Nemotron3DiarizationSpeakerCache](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationSpeakerCache). Một bản ghi âm hoàn chỉnh được chia khối bởi chính hàm forward (chế độ ngoại tuyến); một luồng được nạp một khối mỗi lần forward (chế độ streaming).

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor). Xem `NemotronAsrStreamingFeatureExtractor.__call__()` để biết chi tiết ([Nemotron3DiarizationProcessor](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) sử dụng [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) để xử lý âm thanh).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *tùy chọn*) : Trạng thái streaming được trả về bởi forward của chunk trước đó của cùng các luồng âm thanh.

num_lookahead_frames (`int`, *optional*) : Chế độ streaming: số lượng khung encoder cuối cùng của đầu vào chỉ dùng để nhìn trước. Chúng được chú ý đến, nhưng logits của chúng không được trả về và chúng không tham gia hàng đợi FIFO, vì chúng mở ra khối tiếp theo. [Nemotron3DiarizationProcessor](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) đặt giá trị này cho mọi khối ngoại trừ khối cuối cùng của một phiên. Các đối số này và `num_lookback_frames` xác định chế độ. Chế độ streaming, một khối mỗi lần forward: `num_lookahead_frames` hoặc `num_lookback_frames` được cung cấp (khối đầu tiên tạo `speaker_cache`, các khối sau nhận nó), hoặc `speaker_cache` được cung cấp đơn lẻ (khối cuối cùng của phiên, không nhìn trước). Đầu vào trừ đi các khung nhìn lại và nhìn trước là một khối, bất kể độ dài của nó, được đẩy nguyên khối vào hàng đợi FIFO có kích thước do `config.streaming_config` xác định. Chế độ offline, không có đối số nào được cung cấp: đầu vào là một bản ghi âm hoàn chỉnh, được forward chia thành các khối gồm `config.chunk_length` khung encoder, lấy tối đa `config.chunk_left_context` khung nhìn lại từ các khối trước đó và tối đa `config.chunk_right_context` khung nhìn trước từ các khối tiếp theo, với hàng đợi FIFO có kích thước do `config.fifo_length` xác định; không có cache nào được trả về.

num_lookback_frames (`int`, *optional*) : Chế độ streaming: số lượng khung encoder đầu vào ở phía trước chỉ dùng để nhìn lại, tức là phần cuối của chunk trước được đưa lại phía trước chunk này, nằm trên các khung của `speaker_cache`. Chúng được chú ý đến, nhưng logits của chúng không được trả về và chúng không quay lại hàng đợi FIFO. Mặc định là 0.

**Trả về:** [Nemotron3DiarizationOutput](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) hoặc `tuple(torch.Tensor)`

Một [Nemotron3DiarizationOutput](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([Nemotron3DiarizationConfig](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) và đầu vào.

Phương thức forward của [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/vi/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **logits** (`torch.Tensor` có shape `(batch_size, num_frames, config.head_config.num_speakers)`) -- Logits hoạt động của từng người nói theo từng frame ở tốc độ frame của spectrogram. `logits.sigmoid()` cho xác suất mỗi người nói đang hoạt động trong từng frame; các người nói được sắp xếp theo thứ tự xuất hiện đầu tiên trong âm thanh.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True`) -- Trạng thái ẩn của encoder cho từng chunk, theo thứ tự chunk: encoder chạy một lần cho mỗi chunk, nên bộ tuple chứa `config.audio_config.num_hidden_layers + 1` tensor cho mỗi chunk. Độ dài chuỗi của chúng là độ dài của chunk, bao gồm cả các khung cache và look-ahead.
- **attentions** (`tuple[torch.Tensor, ...]`, *tuỳ chọn*, được trả về khi `output_attentions=True`) -- Trọng số attention của encoder cho mọi chunk, theo thứ tự chunk, mỗi chunk có `config.audio_config.num_hidden_layers` tensor.
- **speaker_cache** (`Nemotron3DiarizationSpeakerCache`, *optional*, được trả về ở chế độ streaming) -- Trạng thái streaming đã cập nhật, để truyền vào forward của chunk audio tiếp theo của cùng các stream.

Ví dụ:

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