# Nemotron 3 Konuşmacı Ayrıştırma

## Genel Bakış

Nemotron 3 Diarization, gerçek dünya seslerinde "kimin ne zaman konuştuğunu" belirlemek üzere tasarlanmış, açık ağırlıklı bir akış konuşmacı ayrıştırma modelidir. Hem akış hem de çevrimdışı çıkarımı destekler, en fazla sekiz konuşmacıyı işler ve konuşmacı çıktıları, her konuşmacının girdi sesindeki ilk varlığına göre sıralanır.

Model, Streaming Sortformer için tanıtılan [1](https://huggingface.co/papers/2507.18446) ve [1](https://huggingface.co/papers/2507.18446), [2](https://huggingface.co/papers/2409.06656) Arrival-Order Speaker Cache (AOSC) ile FIFO kuyruğunu kullanır. Tek bir checkpoint, 80 ms'lik bir giriş tamponundan 30,4 sn'lik çevrimdışı tarzı bir tampona kadar yapılandırılabilir gecikme profillerini ve 10 ms'nin katları şeklinde yapılandırılabilir çıktı çerçeve çözünürlüğünü destekler. Parçalı çıkarım (chunked inference) ile maksimum ses süresi sınırlı değildir.

## Kullanım

### Çevrimdışı

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

### Akış

Ses, parça parça gelir ve her ileri geçiş bir parçayı işler: işlemci, `streaming_mode` için onu keser ve `num_lookahead_frames` ekler; bu, modelin dikkate aldığı ancak puanlamadığı, sonraki parçayı açtığı için skorlanmayan sonda bakış çerçevelerinin sayısıdır. İleri geçiş, sonraki çağrıya aktarılacak `speaker_cache` değerini döndürür. Bir oturumun son parçası `is_last_audio_chunk=True` ile çıkarılır: bu parçada sonda bakış olmadığından, kalan tüm çerçeveler puanlanır.

| `streaming_mode`          | Gecikme¹ |
| ------------------------- | -------- |
| `"low_latency"` (varsayılan) | 1.04 s   |
| `"very_low_latency"`      | 0.64 s   |
| `"ultra_low_latency"`     | 0.32 s   |

¹ Modelin bir parça üzerinde çalışmadan önce beklemesi gereken ses: hesaplama süresi hariç, parça ve ileriye bakma (look-ahead) süresi.

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

### Hızlandırmak

Bir akış adımının kodlayıcı girişi `[speaker cache | FIFO | chunk]` biçimindedir; önbellek ve FIFO doldukça ve küçüldükçe uzunluğu değişir: `torch.compile` bir oturumda yaklaşık yüz kez yeniden derleme yapardı. Her adımı modun en büyük penceresine kadar doldurmak (padding) şekli sabitler. Konumlar her parçada (chunk) sıfırdan başlar, bu nedenle sağ doldurma (right padding) geçerli kareleri değiştirmez:

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

Yukarıdaki akış döngüsü bir kez derlenir. Çevrimdışı ileri geçiş de aynı şekilde parçalara ayrılır, bu nedenle aynı sarmalayıcı `max_window` içinde `config.fifo_length`, `config.chunk_left_context`, `config.chunk_length` ve `config.chunk_right_context` ile uygulanır.

| Hızlanma oranı (eager'a kıyasla) (A100, batch boyutu 1) | float32 | bfloat16 |
| ------------------------------------- | ------- | -------- |
| akış, adım başına                   | 1.2x    | 4.4x     |
| çevrimdışı, 488 s kayıtlı              | 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)
```

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

**Parametreler:**

audio_config (`Nemotron3DiarizationAudioConfig` veya `dict`, *isteğe bağlı*) : Transformer ses kodlayıcısının yapılandırması. Varsayılan olarak `Nemotron3DiarizationAudioConfig()`.

head_config (`Nemotron3DiarizationHeadConfig` veya `dict`, *isteğe bağlı*) : Konuşmacı başlığının yapılandırması. Varsayılan olarak `Nemotron3DiarizationHeadConfig()`.

streaming_config (`Nemotron3DiarizationStreamingConfig` veya `dict`, *isteğe bağlı*) : Konuşmacı önbelleği politikası ve akış modunun FIFO boyutları. Varsayılan olarak `Nemotron3DiarizationStreamingConfig()`.

chunk_length (`int`, *opsiyonel*, varsayılan 340) : Çevrimdışı mod: tüm bir kayıt tek bir ileri geçişte ayrıştırıldığında parça başına kodlayıcı çerçeve sayısı. Akış modunda parça, her ileri geçişin girdisidir.

chunk_right_context (`int`, *isteğe bağlı*, varsayılan 40) : Çevrimdışı modda: her parçanın bir sonraki parçalardan aldığı ileriye dönük kodlayıcı çerçevesi sayısı. Akış modunda ileriye dönük değer her ileri geçişte `num_lookahead_frames` kadardır.

chunk_left_context (`int`, *opsiyonel*, varsayılan 0) : Çevrimdışı mod: her parçanın, önbelleğe alınmış kareler ile parça arasına yerleştirilen, önceki parçalardan tekrar aldığı geriye dönük kodlayıcı kare sayısı. İleriye dönük bakışta olduğu gibi, bunlara dikkat edilir ancak puanlanmazlar ve FIFO kuyruğuna eklenmezler. Akış modunda geriye dönük bakış, her ileri geçişin `num_lookback_frames` değeridir.

fifo_length (`int`, *isteğe bağlı*, varsayılan 40) : Çevrimdışı mod: en son kodlayıcı karelerinin FIFO kuyruğunun kapasitesi. Akış modu `streaming_config.fifo_length` kullanır.

speaker_cache_update_period (`int`, *isteğe bağlı*, varsayılan 300) : Çevrimdışı mod: kuyruk taşarsa FIFO kuyruğundan konuşmacı önbelleğine taşınan kodlayıcı çerçeve sayısı. Akış modu `streaming_config.speaker_cache_update_period` kullanır.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

Bu, bir Nemotron3DiarizationModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron3 Diarization modelinin örneklenmesi için kullanılır ve model mimarisini tanımlar. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

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

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

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `512`) : Gizli temsillerin boyutu.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `2048`) : MLP temsillerinin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `31`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

num_key_value_heads (`int`, *isteğe bağlı*) : Grouped Query Attention uygulamasında kullanılacak key_value başlarının sayısıdır. `num_key_value_heads=num_attention_heads` ise model Multi Head Attention (MHA) kullanır, `num_key_value_heads=1` ise model Multi Query Attention (MQA) kullanır, aksi halde GQA kullanılır. Çok başlı bir checkpoint'i GQA checkpoint'ine dönüştürürken, her grup key ve value başı, o gruptaki tüm orijinal başların ortalama havuzlanması (meanpooling) ile oluşturulmalıdır. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2305.13245) göz atın. Belirtilmezse, varsayılan olarak `num_attention_heads` kullanılır.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `5000`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

rope_parameters (`dict`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

num_mel_bins (`int`, *isteğe bağlı*, varsayılan `128`) : Her giriş çerçevesi için kullanılan mel özellik sayısı. `AutoFeatureExtractor` sınıfında kullanılan değerle eşleşmelidir.

subsampling_factor (`int`, *opsiyonel*, varsayılan 8) : Tek bir kodlayıcı çerçevesine yığılan ardışık spektrogram çerçevesi sayısı. Sınıflayıcı, çıktılarını aynı katsayıyla yukarı örnekler, böylece konuşmacı aktivitesi spektrogram çerçevesi hızında tahmin edilir.

Bu, bir Nemotron3DiarizationModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron3 Diarization modelinin örneklenmesi için kullanılır ve model mimarisini tanımlar. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

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

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

**Parametreler:**

hidden_size (`int`, *opsiyonel*, varsayılan 192) : Konuşmacı başlığının gizli boyutu: kodlayıcı çıktısı buna yansıtılır ve yükseltici ile sınıflandırıcı bunu korur.

num_speakers (`int`, *isteğe bağlı*, varsayılan 8) : Maksimum konuşmacı sayısı, yani çerçe başına aktivite çıktıları sayısı. Konuşmacılar, ses dosyasındaki ilk görünümlerine göre sıralanır.

audio_hidden_size (`int`, *opsiyonel*, varsayılan 512) : Başın projeksiyon yaptığı kodlayıcı çıktısının gizli boyutu. `Nemotron3DiarizationAudioConfig.hidden_size` ile eşleşmelidir.

subsampling_factor (`int`, *opsiyonel*, varsayılan 8) : Başın, spektrogram çerçeve hızına geri döndürmek için kullanılan örnekleme artırma (upsampling) çarpanı. `Nemotron3DiarizationAudioConfig.subsampling_factor` ile eşleşmelidir.

Bu, bir Nemotron3DiarizationModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron3 Diarization modelinin örneklenmesi için kullanılır ve model mimarisini tanımlar. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

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

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

**Parametreler:**

fifo_length (`int`, *opsiyonel*, varsayılan 264) : Akış modunda en son kodlayıcı karelerinin FIFO kuyruğunun kapasitesi (çevrimdışı mod `Nemotron3DiarizationConfig.fifo_length` kullanır).

speaker_cache_update_period (`int`, *opsiyonel*, varsayılan 222) : Akış modunda kuyruk taşarsa FIFO kuyruğundan konuşmacı önbelleğine taşınan kodlayıcı çerçeve sayısı (çevrimdışı mod `Nemotron3DiarizationConfig.speaker_cache_update_period` kullanır).

speaker_cache_length (`int`, *isteğe bağlı*, varsayılan 264) : Arrival-Order Speaker Cache kapasitesi. En az `(1 + speaker_cache_silence_frames_per_speaker) * num_speakers` olmalıdır.

speaker_cache_silence_frames_per_speaker (`int`, *isteğe bağlı*, varsayılan 1) : Önbellek sıkıştırıldığında, öğrenilen sessizlik gömme için konuşmacı başına ayrılan konuşmacı-önbellek yuvası sayısı.

prediction_score_threshold (`float`, *opsiyonel*, varsayılan 0.25) : Konuşmacı önbelleği çerçeve puanlarında logaritma alınmadan önce konuşmacı olasılıklarının alt sınırı.

latest_frames_score_boost (`float`, *opsiyonel*, varsayılan 0.05) : Konuşmacı önbelleği sıkıştırıldığında, önbelleğe yeni eklenen karelere verilen puan bonusu.

strong_boost_rate (`float`, *opsiyonel*, varsayılan 0.75) : Konuşmacı başına önbellek bütçesinin, güçlü bir puan artışı alan en iyi karelerin oranı; böylece her konuşmacı önbellekte en az bu kadar kare tutar.

weak_boost_rate (`float`, *opsiyonel*, varsayılan 1.5) : Konuşmacı başına önbellek bütçesinin, en iyi karelerine zayıf bir puan artışı uygulanarak tek bir konuşmacının önbelleği domine etmesinin önlenmesini sağlayan oranı.

min_positive_scores_rate (`float`, *opsiyonel*, varsayılan 0.5) : Konuşmacı başına önbellek bütçesinin oranı: en az bu kadar pozitif puanlı karesi olan bir konuşmacının pozitif olmayan (üst üste binen konuşma) kareleri önbellekten hariç tutulur.

num_speakers (`int`, *isteğe bağlı*, varsayılan 8) : Konuşmacı önbelleği tarafından takip edilen konuşmacı sayısı. `Nemotron3DiarizationHeadConfig.num_speakers` ile eşleşmelidir.

subsampling_factor (`int`, *isteğe bağlı*, varsayılan 8) : Her kodlayıcı çerçevesi başına konuşmacı olasılığı çerçevesi sayısı. `Nemotron3DiarizationAudioConfig.subsampling_factor` ile eşleşmelidir.

Bu, bir Nemotron3DiarizationModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Nemotron3 Diarization modelinin örneklenmesi için kullanılır ve model mimarisini tanımlar. Varsayılan değerlerle bir yapılandırma örneği oluşturmak, [nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

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

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

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

**Parametreler:**

config ([Nemotron3DiarizationAudioConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel head bulunmayan, ham hidden-state çıktısı üreten çıplak Nemotron3 Diarization Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanılarak elde edilebilir. Ayrıntılar için `NemotronAsrStreamingFeatureExtractor.__call__()` bölümüne bakın ([Nemotron3DiarizationProcessor](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor), sesleri işlemek için [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

position_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizileri token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

**Dönüş:** [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Nemotron3DiarizationConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Nemotron3DiarizationAudioModel](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

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

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

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

**Parametreler:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Konuşmacı sınıflandırıcısı olmadan Nemotron3Diarization modeli: bir parçayı (önbelleğe alınmış kareleriyle birlikte) kodlar ve kodlayıcı karelerini spektrogram kare hızına geri örnekler. Akış durumunu (streaming state) tutmaz, parçalı ileri işlem için [Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) sınıfına bakın.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanılarak elde edilebilir. Ayrıntılar için `NemotronAsrStreamingFeatureExtractor.__call__()` bölümüne bakın ([Nemotron3DiarizationProcessor](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor), sesleri işlemek için [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

position_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizileri token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

**Dönüş:** [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Nemotron3DiarizationConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Nemotron3DiarizationModel](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

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

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

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

**Parametreler:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : Özellik çıkarıcı zorunlu bir girdidir.

subsampling_factor (`int`, *isteğe bağlı*, varsayılan 8) : Her kodlayıcı çerçevesi başına mel çerçeve sayısı, `Nemotron3DiarizationAudioConfig.subsampling_factor` ile aynıdır.

streaming_modes (`dict[str, tuple[int, int]]`, *isteğe bağlı*) : Kontrol noktasının desteklediği akış modları, adların kodlayıcı çerçevelerinde `(chunk_length, chunk_right_context)` karşılıkları. Bu kümenin tek doğruluk kaynağı işleyicidir: `set_streaming_mode()` bunu doğrular. Varsayılan olarak model kartı modlarıdır: `"low_latency"` (9, 4), `"very_low_latency"` (6, 2) ve `"ultra_low_latency"` (3, 1).

streaming_mode (`str`, *isteğe bağlı*, varsayılan `"low_latency"`) : Oturumların akış modu, `streaming_modes` değerlerinden biri; `set_streaming_mode()` ile değiştirilir. Çevrimdışı kullanım bunu yoksayar.

Bir özellik çıkarıcıyı (feature extractor) tek bir işlemciye (processor) saran bir Nemotron3DiarizationProcessor oluşturur.

[Nemotron3DiarizationProcessor](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor), [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor)'in tüm işlevlerini sunar. Daha fazla bilgi için [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) sayfasına bakın.

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

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

**Parametreler:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

sampling_rate (`int`, *isteğe bağlı*) : Girdi sesinin Hz cinsinden örneklem hızı. Verildiğinde, özellik çıkarıcının beklenen örneklem hızıyla (16000 Hz) doğrulanır.

is_streaming (`bool`, *isteğe bağlı*, varsayılan `False`) : Sesin bir akış oturumunun parçası olup olmadığı, `is_first_audio_chunk` ve `is_last_audio_chunk` ile ilk ve son parçaların diğerlerinden ayrılması. Parça boyutları, `set_streaming_mode()` ile değiştirilen `streaming_mode` boyutlarıdır. Son parça hariç her parça, ilk parça için tam olarak `num_samples_first_audio_chunk` ve sonraki parçalar için `num_samples_per_audio_chunk` ses örneği içermelidir.

is_first_audio_chunk (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu, bir akış oturumunun ilk parçası mı? Özellik çıkarıcı, ilk parça ve çevrimdışı kullanım için analiz pencerelerini ortalar (`center=True`), sonraki parçalar için ise ortalamaz (`center=False`); böylece parça başına spektrogram, çerçeve çerçeve, tek bir tam ifade geçişini yeniden üretir. `is_streaming=False` olduğunda `True` olmalıdır.

is_last_audio_chunk (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu parçanın akış oturumunu sonlandırıp sonlandırmadığını belirtir. Bir oturumun parçası, modelin yalnızca bir sonraki adımda puanladığı ve bir sonraki parçasının açılışını yaptığı `chunk_right_context` ileriye dönük kodlayıcı çerçeveleriyle sona erer. Son parçanın bir sonraki adımı olmadığından, çerçevelerinin sayısı ne olursa olsun hepsi puanlanır ve sonu, tam bir ifade geçişinin sesin sonunu doldurduğu gibi sıfır dolgulu olur; böylece ifadenin son çerçevelerini üretir. `is_streaming=False` olduğunda `False` olmalıdır.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

**Dönüş:** [BatchFeature](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.BatchFeature)

özellik çıkarıcısının çıktıları, `input_features` ve `attention_mask`. Akış modunda, analiz penceresi sondan bir önceki parçanın dışına uzanan son kareler atılır; bu nedenle `input_features` tam olarak parçanın karelerini içerir ve modele olduğu gibi aktarılabilir. Ayrıca sondaki parça hariç her parça, modelin akış moduna geçmesini sağlayan, sonundaki ileriye dönük kodlayıcı karelerinin sayısını temsil eden `num_lookahead_frames` değerini taşır.

## Nemotron3DiarizationSpeakerCache[[transformers.Nemotron3DiarizationSpeakerCache]]

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

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

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

**Parametreler:**

config (`Nemotron3DiarizationStreamingConfig`) : Konuşmacı önbelleği politikası ve akış modunun FIFO boyutları.

fifo_length (`int`, *isteğe bağlı*) : En son kodlayıcı karelerinin FIFO kuyruğunun kapasitesi. Varsayılan olarak `config.fifo_length`'tir.

speaker_cache_update_period (`int`, *opsiyonel*) : Kuyruk taşması durumunda FIFO kuyruğundan konuşmacı önbelleğine taşınan kodlayıcı çerçeve sayısı. Varsayılan olarak `config.speaker_cache_update_period`'tür.

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) durumunun akışı: varış sırasına göre konuşmacı önbelleği ve her parçanın dikkate aldığı en son kodlayıcı çerçevelerinin FIFO kuyruğu.

#### güncelle[[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)
```

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

**Parametreler:**

chunk_input_embeds (`torch.Tensor`, şekli `(batch_size, num_input_frames, hidden_size)`) : Adımın kodlayıcı girdisi: `get_embeds` tarafından döndürülen önbelleğe alınmış kareler, geriye dönük kareler, parça ve ileriye dönük kareler.

chunk_logits (`torch.Tensor`, şekli `(batch_size, num_input_frames * subsampling_factor, num_speakers)`) : Konuşmacı önbelleği sıkıştırıldığında kareleri puanlamak için kullanılan adımın konuşmacı logitleri.

silence_embeds (`torch.Tensor`, şekli `(hidden_size,)`) : Sıkıştırılmış önbellekteki ayrılmış sessizlik yuvalarını dolduran öğrenilmiş sessizlik gömme (embedding).

num_chunk_frames (`int`) : `chunk_input_embeds` içindeki önbelleğe alınmış ve geriye dönük karelerin ardından gelen parça karelerinin sayısı. FIFO kuyruğuna yalnızca bunlar eklenir: bunların sonraki ileriye dönük kareleri bir sonraki adımda yeniden beslenir.

mask (`torch.Tensor`, şekli `(batch_size, num_input_frames)`, *isteğe bağlı*) : `chunk_input_embeds`'ün geçerli kareleri; dolgu kareleri için konuşmacı olasılıkları sıfır olarak verilir.

num_lookback_frames (`int`, *isteğe bağlı*, varsayılan 0) : `chunk_input_embeds` içindeki önbelleğe alınmış kareler ile parça arasındaki geriye dönük kare sayısı: önceki parçanın kareleri, onunla birlikte zaten gönderilmiş olanlar, tekrar beslenir.

İşlenmiş bir parçayı FIFO kuyruğuna iter ve taşma durumunda en eski karelerini konuşmacı önbelleğine taşır.

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

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

**Parametreler:**

logits (`torch.Tensor`, şekli `(batch_size, num_frames, config.head_config.num_speakers)`) : Spektrogram kare hızında, kare başına konuşmacı aktivite logitleri. `logits.sigmoid()`, her konuşmacının her karede aktif olma olasılığını verir; konuşmacılar, ses dosyasındaki ilk varış sıralarına göre sıralanır.

hidden_states (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` olduğunda döndürülür) : Parça sırasına göre her parçanın kodlayıcı gizli durumları: kodlayıcı parça başına bir kez çalıştığından, bu demet parça başına `config.audio_config.num_hidden_layers + 1` tensör içerir. Sıraları uzunlukları, önbellek ve ileriye dönük kareleri de kapsar.

attentions (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) : Her parçanın kodlayıcı dikkat ağırlıkları, parça sırasına göre, parça başına `config.audio_config.num_hidden_layers` tensör.

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *isteğe bağlı*, akış modunda döndürülür) : Aynı akışların bir sonraki ses diliminin forward'ına iletilmek üzere güncellenmiş akış durumu.

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) çıktısı.

## Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

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

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

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

**Parametreler:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Streaming Sortformer konuşmacı ayrıştırma modeli: her spektrogram çerçevesi için, ilk geliş sırasına göre sıralanmış en fazla `config.head_config.num_speakers` konuşmacının aktivitesini tahmin eder. Ses, parça parça işlenir; her parça, birkaç ileriye bakış çerçevesine ve [Nemotron3DiarizationSpeakerCache](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationSpeakerCache) içinde taşınan Arrival-Order Speaker Cache ile FIFO kuyruğuna dikkat eder. Tüm bir kayıt, forward tarafından parçalara ayrılır (çevrimdışı mod); bir akış ise her forward'da bir parça olarak beslenir (streaming modu).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanılarak elde edilebilir. Ayrıntılar için `NemotronAsrStreamingFeatureExtractor.__call__()` bölümüne bakın ([Nemotron3DiarizationProcessor](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor), sesleri işlemek için [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/tr/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *isteğe bağlı*) : Aynı ses akışlarının önceki parçasının forward'undan döndürülen akış durumu.

num_lookahead_frames (`int`, *opsiyonel*) : Akış modu: girdinin yalnızca ileriye bakış (look-ahead) olarak kullanılan, sonda kalan kodlayıcı çerçeve sayısı. Bunlara dikkat edilir ancak logit'leri döndürülmez ve sonraki parçayı açtıkları için FIFO kuyruğuna eklenmezler. [Nemotron3DiarizationProcessor](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor), bir oturumdaki son parça hariç her parça için bunu ayarlar. Bu argümanlar ve `num_lookback_frames` modu seçer. Akış modu, ileriye doğru bir parça: `num_lookahead_frames` veya `num_lookback_frames` verilmişse (ilk parça `speaker_cache` oluşturur, sonraki parçalar bunu alır) ya da yalnızca `speaker_cache` verilmişse (oturumun son parçası, ileriye bakış yok). Girdinin geriye bakış (look-back) ve ileriye bakış (look-ahead) çerçeveleri çıkarıldıktan sonra kalan kısmı, uzunluğu ne olursa olsun tek bir parçadır ve `config.streaming_config` ile boyutlandırılan FIFO kuyruğuna bütün olarak itilir. Çevrimdışı mod, ikisi de verilmediyse: girdi tüm bir kayıttır ve ileriye doğru işlem, `config.chunk_length` kodlayıcı çerçeveden oluşan parçalara böler; bu parçalar, öncekilerden en fazla `config.chunk_left_context` geriye bakış çerçevesi ve sonrakilerden en fazla `config.chunk_right_context` ileriye bakış çerçevesi alır, `config.fifo_length` ile boyutlandırılan bir FIFO kuyruğu kullanılır; önbellek döndürülmez.

num_lookback_frames (`int`, *opsiyonel*) : Akış modu: Girdinin, yalnızca geriye bakış (look-back) için kullanılan, önceki parçanın sonunun bu parçanın başına `speaker_cache` çerçevelerinin üzerine eklenmesiyle oluşturulan baştaki kodlayıcı çerçeve sayısı. Bu çerçevelere dikkat edilir ancak logit'leri döndürülmez ve FIFO kuyruğuna tekrar eklenmezler. Varsayılan değer 0'dır.

**Dönüş:** [Nemotron3DiarizationOutput](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) veya `tuple(torch.Tensor)`

[Nemotron3DiarizationOutput](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Nemotron3DiarizationConfig](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/tr/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **logits** (`torch.Tensor`, şekli `(batch_size, num_frames, config.head_config.num_speakers)`) -- Spektrogram çerçeve hızında, çerçeve başına konuşmacı aktivite logitleri. `logits.sigmoid()`, her konuşmacının her çerçevede aktif olma olasılığını verir; konuşmacılar, ses dosyasındaki ilk varış sıralarına göre sıralanır.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsiyonel*, `output_hidden_states=True` olduğunda döndürülür) -- Parça sırasına göre her parçanın kodlayıcı gizli durumları: kodlayıcı parça başına bir kez çalıştığından, bu demet her parça için `config.audio_config.num_hidden_layers + 1` tensör içerir. Sıraları uzunlukları, parçanınkine eşittir; önbellek ve ileriye dönük kareler dahildir.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) -- Her parçanın encoder dikkat ağırlıkları, parça sırasına göre, parça başına `config.audio_config.num_hidden_layers` tensör.
- **speaker_cache** (`Nemotron3DiarizationSpeakerCache`, *isteğe bağlı*, akış modunda döndürülür) -- Aynı akışların bir sonraki ses dilimi için ileriye (forward) geçirilecek güncellenmiş akış durumu.

Örnek:

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