# Nemotron 3 Diarization

## 概要

Nemotron 3 Diarization は、実世界の音声で「誰がいつ話したか」を判定するために設計された、オープンウェイトのストリーミング型話者分離モデルです。ストリーミング推論とオフライン推論の両方をサポートし、最大8人の話者を処理できます。また、話者の出力は、入力音声における各話者の初回出現順に並べられます。

モデルは、Streaming Sortformer [1](https://huggingface.co/papers/2507.18446)、[2](https://huggingface.co/papers/2409.06656) で導入された Arrival-Order Speaker Cache (AOSC) [1](https://huggingface.co/papers/2507.18446) および FIFO キューを使用しています。単一のチェックポイントで、80 ms の入力バッファから 30.4 秒のオフライン風バッファまでの設定可能なレイテンシプロファイル、および 10 ms の倍数で設定可能な出力フレーム解像度をサポートします。チャンク推論を使用する場合、最大音声長は制限されません。

## 使用方法

### オフライン

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

### ストリーミング

Audio はチャンク単位で到着し、各 forward は 1 つのチャンクを処理します。プロセッサは `streaming_mode` に基づいてチャンクを切り出し、`num_lookahead_frames` 分（モデルが注意はするがスコアリングしない、次のチャンクを開くための末尾のルックアヘッドフレーム数）を追加します。forward は、次の呼び出しに渡すための `speaker_cache` を返します。セッションの最後のチャンクは `is_last_audio_chunk=True` で抽出されます。このチャンクにはルックアヘッドがないため、残りのすべてのフレームがスコアリングされます。

| `streaming_mode`          | レイテンシー¹ |
| ------------------------- | -------- |
| `"low_latency"`（デフォルト） | 1.04 s   |
| `"very_low_latency"`      | 0.64 s   |
| `"ultra_low_latency"`     | 0.32 s   |

¹ モデルがチャンクを実行する前に待機するオーディオ: 計算時間を除いた、チャンクとそのルックアヘッドの合計。

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

### 高速化

ストリーミングステップのエンコーダー入力は`[speaker cache | FIFO | chunk]`であり、キャッシュとFIFOが埋まっていくにつれて、また縮小していくにつれて、その長さが変化します。`torch.compile`を使用すると、セッションごとに約100回再コンパイルされてしまいます。各ステップをモードの最大ウィンドウにパディングすることで、形状を固定できます。各チャンクで位置がゼロから再開されるため、右パディングは有効なフレームに影響しません。

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

上記のストリーミングループは1回だけコンパイルされます。オフラインのフォワードも同様にチャンク分割されるため、`max_window` に `config.fifo_length`、`config.chunk_left_context`、`config.chunk_length`、`config.chunk_right_context` を指定した同じラッパーが適用されます。

| Eager に対する高速化率（A100、バッチサイズ 1） | float32 | bfloat16 |
| ------------------------------------- | ------- | -------- |
| ストリーミング、ステップごと                   | 1.2x    | 4.4x     |
| オフライン、488秒の録音              | 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)
```

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

**パラメータ:**

audio_config (`Nemotron3DiarizationAudioConfig` または `dict`、*任意*) : Transformerオーディオエンコーダーの設定。デフォルトは `Nemotron3DiarizationAudioConfig()` です。

head_config (`Nemotron3DiarizationHeadConfig` または `dict`、*任意*) : スピーカーヘッドの設定。デフォルトは `Nemotron3DiarizationHeadConfig()` です。

streaming_config (`Nemotron3DiarizationStreamingConfig` または `dict`、*任意*) : スピーカーキャッシュのポリシーと、ストリーミングモードのFIFOサイズ。デフォルトは `Nemotron3DiarizationStreamingConfig()` です。

chunk_length (`int`, *optional*, デフォルトは 340) : オフラインモード: 録音全体を 1 回のフォワードで話者分離する場合のチャンクあたりのエンコーダフレーム数。ストリーミングモードでは、チャンクは各フォワードの入力です。

chunk_right_context (`int`、*optional*、デフォルトは 40) : オフラインモード: 各チャンクが後続のチャンクから取得するルックアヘッドエンコーダーフレームの数。ストリーミングモードでは、ルックアヘッドは各フォワードの `num_lookahead_frames` です。

chunk_left_context (`int`、*optional*、デフォルトは 0) : オフラインモード: 各チャンクが、キャッシュされたフレームとチャンクの間に挿入される形で、直前のフレームから再度取得するルックバックエンコーダフレームの数です。ルックアヘッドと同様に、これらはアテンションの対象となりますが、スコアリングも FIFO キューへのプッシュもされません。ストリーミングモードでは、ルックバックは各フォワードの `num_lookback_frames` です。

fifo_length (`int`、*optional*、デフォルトは 40) : オフラインモード: 直近のエンコーダーフレームの FIFO キューの容量。ストリーミングモードでは `streaming_config.fifo_length` が使用されます。

speaker_cache_update_period (`int`、*optional*、デフォルトは 300) : オフラインモード: キューがオーバーフローした際に、FIFO キューからスピーカーキャッシュへ移動されるエンコーダーフレームの数。ストリーミングモードでは `streaming_config.speaker_cache_update_period` が使用されます。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

これは、Nemotron3DiarizationModel の設定を保存するための設定クラスです。指定された引数に基づいて Nemotron3 Diarization モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

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

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

**パラメータ:**

hidden_size (`int`、*任意*、デフォルトは`512`) : 隠れ表現の次元数。

intermediate_size (`int`、*任意*、デフォルトは`2048`) : MLP 表現の次元数。

num_hidden_layers (`int`, *任意*, デフォルトは `31`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

num_key_value_heads (`int`, *optional*) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA チェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。

hidden_act (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。

max_position_embeddings (`int`、*optional*、デフォルトは`5000`) : このモデルが使用される可能性のある最大シーケンス長。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

rope_parameters (`dict`, *任意*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれており、より長い `max_position_embeddings` で RoPE を使用する場合にスケーリングに使用されるパラメータが任意で含まれます。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

num_mel_bins (`int`、*任意*、デフォルトは`128`) : 入力フレームごとに使用されるメル特徴の数を指定します。`AutoFeatureExtractor`クラスで使用される値と一致させる必要があります。

subsampling_factor (`int`、*optional*、デフォルトは 8) : 1 つのエンコーダーフレームにスタックされる連続スペクトログラムフレームの数です。分類器は出力を同じ係数でアップサンプリングするため、話者の活動はスペクトログラムフレームレートで予測されます。

これは、Nemotron3DiarizationModel の設定を保存するための設定クラスです。指定された引数に基づいて Nemotron3 Diarization モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

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

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

**パラメータ:**

hidden_size (`int`, *optional*, デフォルトは 192) : スピーカーヘッドの隠れ層サイズ: エンコーダーの出力はこれに射影され、アップサンプラーと分類器はこれを保持します。

num_speakers (`int`、*optional*、デフォルトは 8) : 最大話者数、つまりフレームごとの活動出力の数です。話者は、音声内で最初に検出された順序で並べられます。

audio_hidden_size (`int`、*optional*、デフォルトは 512) : ヘッドが射影するエンコーダー出力の隠れ層サイズ。`Nemotron3DiarizationAudioConfig.hidden_size` と一致する必要があります。

subsampling_factor (`int`、*optional*、デフォルトは 8) : ヘッドのアップサンプリング係数。スペクトログラムのフレームレートに戻すためのものです。`Nemotron3DiarizationAudioConfig.subsampling_factor` と一致する必要があります。

これは、Nemotron3DiarizationModel の設定を保存するための設定クラスです。指定された引数に基づいて Nemotron3 Diarization モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

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

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

**パラメータ:**

fifo_length (`int`、*optional*、デフォルトは 264) : ストリーミングモードにおける直近のエンコーダーフレームの FIFO キューの容量（オフラインモードでは `Nemotron3DiarizationConfig.fifo_length` が使用されます）。

speaker_cache_update_period (`int`、*optional*、デフォルトは 222) : ストリーミングモードにおいて、FIFO キューがオーバーフローした際に、キューからスピーカーキャッシュへ移動されるエンコーダーフレームの数です（オフラインモードでは `Nemotron3DiarizationConfig.speaker_cache_update_period` が使用されます）。

speaker_cache_length (`int`, *任意*, デフォルトは 264) : Arrival-Order Speaker Cache の容量です。`(1 + speaker_cache_silence_frames_per_speaker) * num_speakers` 以上である必要があります。

speaker_cache_silence_frames_per_speaker (`int`, *optional*, デフォルトは 1) : キャッシュが圧縮された場合、学習された無音埋め込みのために話者ごとに予約される、話者ごとのスピーカーキャッシュのスロット数。

prediction_score_threshold (`float`、*optional*、デフォルト値は 0.25) : スピーカーキャッシュのフレームスコアで、スピーカー確率の対数を求める前に適用される、確率の下限クランプ値。

latest_frames_score_boost (`float`、*optional*、デフォルトは 0.05) : スピーカーキャッシュが圧縮された際に、新たに追加されたフレームに付与されるスコアボーナスです。

strong_boost_rate (`float`、*optional*、デフォルトは 0.75) : 話者ごとのキャッシュ予算のうち、最高のフレームに強いスコアブーストを適用する割合です。これにより、各話者はキャッシュに少なくともその数だけフレームを保持します。

weak_boost_rate (`float`、*optional*、デフォルトは 1.5) : 話者ごとのキャッシュ予算のうち、最良のフレームに弱いスコアブーストを付与する割合です。これにより、ある1人の話者がキャッシュを独占することを防ぎます。

min_positive_scores_rate (`float`、*optional*、デフォルトは 0.5) : 話者ごとのキャッシュ予算に対する割合: 正のスコアを持つフレームがこの数以上ある話者の場合、非正のスコア（重なり話）のフレームはキャッシュから除外されます。

num_speakers (`int`、*optional*、デフォルトは 8) : スピーカーキャッシュによって追跡される話者の数。`Nemotron3DiarizationHeadConfig.num_speakers` と一致する必要があります。

subsampling_factor (`int`、*optional*、デフォルトは 8) : エンコーダーフレームあたりの話者確率フレーム数。`Nemotron3DiarizationAudioConfig.subsampling_factor` と一致する必要があります。

これは、Nemotron3DiarizationModel の設定を保存するための設定クラスです。指定された引数に基づいて Nemotron3 Diarization モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[nvidia/Nemotron-3-Diarization](https://huggingface.co/nvidia/Nemotron-3-Diarization) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

## Nemotron3DiarizationAudioModel[[transformers.Nemotron3DiarizationAudioModel]]

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

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

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

**パラメータ:**

config ([Nemotron3DiarizationAudioConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

生の隠れ状態を出力し、上部に特定のヘッドを持たない、素の Nemotron3 Diarization Model です。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

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

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

**パラメータ:**

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用して取得できます。詳細は `NemotronAsrStreamingFeatureExtractor.__call__()` を参照してください（[Nemotron3DiarizationProcessor](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) は音声の処理に [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用します）。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

**戻り値:** [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.Tensor)`

設定（[Nemotron3DiarizationConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)）や入力に応じて、さまざまな要素で構成される [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[Nemotron3DiarizationAudioModel](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationAudioModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## Nemotron3DiarizationModel[[transformers.Nemotron3DiarizationModel]]

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

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

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

**パラメータ:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

話者分類器を含まないNemotron3Diarizationモデル: 1チャンク（キャッシュされたフレームを含む）をエンコードし、エンコーダーのフレームをスペクトログラムのフレームレートにアップサンプリングします。ストリーミング状態は保持せず、チャンク化されたフォワードについては[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification)を参照してください。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

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

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

**パラメータ:**

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用して取得できます。詳細は `NemotronAsrStreamingFeatureExtractor.__call__()` を参照してください（[Nemotron3DiarizationProcessor](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) は音声の処理に [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用します）。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

position_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。`[0, config.n_positions - 1]` の範囲から選択されます。  [位置 ID とは何か？](../glossary#position-ids)

**戻り値:** [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.Tensor)`

設定（[Nemotron3DiarizationConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)）や入力に応じて、さまざまな要素で構成される [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[Nemotron3DiarizationModel](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## Nemotron3DiarizationProcessor[[transformers.Nemotron3DiarizationProcessor]]

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

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

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

**パラメータ:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : 特徴抽出器は必須の入力です。

subsampling_factor (`int`、*optional*、デフォルトは 8) : エンコーダーフレームあたりの mel フレーム数。`Nemotron3DiarizationAudioConfig.subsampling_factor` と同じです。

streaming_modes (`dict[str, tuple[int, int]]`, *任意*) : チェックポイントがサポートするストリーミングモードです。エンコーダーフレームにおける `(chunk_length, chunk_right_context)` への名前付けです。このセットの唯一の信頼できる情報源はプロセッサであり、`set_streaming_mode()` はこれに対して検証を行います。デフォルトでは、モデルカードのモードである `"low_latency"` (9, 4)、`"very_low_latency"` (6, 2)、`"ultra_low_latency"` (3, 1) が使用されます。

streaming_mode (`str`、*任意*、デフォルトは`"low_latency"`) : セッションのストリーミングモード。`streaming_modes`のいずれかです。`set_streaming_mode()`で変更できます。オフライン使用時は無視されます。

Nemotron3DiarizationProcessor を構築し、フィーチャーエクストラクターを単一のプロセッサーにラップします。

[Nemotron3DiarizationProcessor](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) は [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) のすべての機能を提供します。詳細については、[~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を参照してください。

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

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

**パラメータ:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : 準備対象のオーディオまたはオーディオのバッチです。各オーディオは NumPy 配列または PyTorch テンソルであることができます。NumPy 配列/PyTorch テンソルの場合、各オーディオの形状は (C, T) である必要があります。ここで、C はチャネル数、T はオーディオのサンプル長を表します。

sampling_rate (`int`, *optional*) : 入力オーディオのサンプリングレート（Hz）。指定された場合、フィーチャーエクストラクターが想定するサンプリングレート（16000 Hz）に対して検証されます。

is_streaming (`bool`、*任意*、デフォルトは`False`) : オーディオがストリーミングセッションの1チャンクであるかどうかを示します。`is_first_audio_chunk`と`is_last_audio_chunk`により、最初のチャンクと最後のチャンクを他のチャンクと区別します。チャンクサイズは`streaming_mode`のものです。`set_streaming_mode()`で変更できます。最後のチャンクを除くすべてのチャンクは、最初のチャンクが`num_samples_first_audio_chunk`、それ以降のチャンクが`num_samples_per_audio_chunk`のオーディオサンプルを正確に保持する必要があります。

is_first_audio_chunk (`bool`, *任意*, デフォルトは `True`) : ストリーミングセッションの最初のチャンクかどうかを示します。特徴量抽出器は、最初のチャンクおよびオフライン使用時には解析ウィンドウを中央揃え (`center=True`) にし、それ以降のチャンクでは中央揃にしない (`center=False`) ため、チャンクごとのスペクトログラムが、フレーム単位で単一の完全な発話パスを再現します。`is_streaming=False` の場合は `True` である必要があります。

is_last_audio_chunk (`bool`、*任意*、デフォルトは`False`) : このチャンクがストリーミングセッションを終了するかどうかを示します。セッションのチャンクは、`chunk_right_context` 個のルックアヘッドエンコーダーフレームで終了します。これらのフレームは、モデルが次のステップでのみスコアリングし、次のチャンクがこれらで開始します。最後のチャンクには次のステップがないため、フレーム数がいくつであってもすべてスコアリングされます。また、その末尾は、フルアタランスパスが音声の末尾をパディングするようにゼロパディングされ、アタランスの最後のフレームを出力するようにします。`is_streaming=False` の場合は、`False` である必要があります。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。

**戻り値:** [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature)

特徴抽出器の出力は、`input_features`と`attention_mask`です。ストリーミングモードでは、最後のチャンク以外のチャンクにおいて、解析ウィンドウがそのチャンクを超えて後続のチャンクに達する末尾フレームは破棄されるため、`input_features`にはそのチャンクのフレームが正確に格納され、そのままモデルに渡すことができます。また、最後のチャンク以外のすべてのチャンクには、その末尾のルックアヘッドエンコーダフレーム数である`num_lookahead_frames`が含まれており、これによりモデルがストリーミングモードになります。

## Nemotron3DiarizationSpeakerCache[[transformers.Nemotron3DiarizationSpeakerCache]]

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

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

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

**パラメータ:**

config (`Nemotron3DiarizationStreamingConfig`) : スピーカーキャッシュのポリシーと、ストリーミングモードのFIFOサイズ。

fifo_length (`int`, *optional*) : 直近のエンコーダーフレームのFIFOキューの容量。デフォルトは`config.fifo_length`です。

speaker_cache_update_period (`int`, *optional*) : キューがオーバーフローした際に、FIFOキューからスピーカーキャッシュへ移動されるエンコーダーフレームの数。デフォルト値は`config.speaker_cache_update_period`です。

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification)のストリーミング状態: 到着順スピーカーキャッシュと、各チャンクがアテンションを向ける直近のエンコーダーフレームのFIFOキュー。

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

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

**パラメータ:**

chunk_input_embeds (`torch.Tensor`、形状 `(batch_size, num_input_frames, hidden_size)`) : ステップのエンコーダー入力: `get_embeds` が返すキャッシュされたフレーム、ルックバックフレーム、チャンクとそのルックアヘッド。

chunk_logits (`torch.Tensor`、形状 `(batch_size, num_input_frames * subsampling_factor, num_speakers)`) : ステップのスピーカー logits。スピーカーキャッシュが圧縮される際に、フレームをスコアリングするために使用されます。

silence_embeds (`torch.Tensor`、形状 `(hidden_size,)`) : 圧縮キャッシュの予約済みサイレンススロットを埋めるために学習されたサイレンス埋め込み。

num_chunk_frames (`int`) : `chunk_input_embeds`内のキャッシュ済みフレームおよびルックバックフレームに続くチャンクフレームの数。FIFOキューに参加するのはこれらのみであり、その後のルックアヘッドフレームは次のステップで再度投入されます。

mask (`torch.Tensor`、形状 `(batch_size, num_input_frames)`、*任意*) : `chunk_input_embeds` の有効なフレーム。パディングフレームにはゼロのスピーカー確率が割り当てられます。

num_lookback_frames (`int`、*optional*、デフォルトは 0) : `chunk_input_embeds` のキャッシュされたフレームとチャンク間のルックバックフレーム数：前のチャンクのフレームが再度投入され、それとともにプッシュ済みのもの。

FIFOキューに処理済みのチャンクをプッシュし、オーバーフローが発生した場合は最も古いフレームをスピーカーキャッシュに移動します。

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

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

**パラメータ:**

logits (`torch.Tensor`、形状 `(batch_size, num_frames, config.head_config.num_speakers)`) : スペクトログラムのフレームレートでの、フレームごとの話者アクティビティの logits。`logits.sigmoid()` は、各フレームで各話者がアクティブである確率を返します。話者は、音声内で最初に検出された順序で並べられています。

hidden_states (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` の場合に返されます) : チャンク順に並べられた、すべてのチャンクのエンコーダーの隠れ状態です。エンコーダーはチャンクごとに1回実行されるため、このタプルにはチャンクごとに`config.audio_config.num_hidden_layers + 1`個のテンソルが含まれます。シーケンス長は、キャッシュおよびルックアヘッドフレームを含む、そのチャンクの長さに等しくなります。

attentions (`tuple[torch.Tensor, ...]`、*optional*、`output_attentions=True` の場合に返されます) : チャンク順に並べられた各チャンクのエンコーダーアテンション重み。各チャンクにつき`config.audio_config.num_hidden_layers`個のテンソル。

speaker_cache (`Nemotron3DiarizationSpeakerCache`、*任意*、ストリーミングモードで返されます) : 同一ストリームの次のオーディオチャンクの forward に渡すための、更新されたストリーミング状態。

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification)の出力です。

## Nemotron3DiarizationForAudioFrameClassification[[transformers.Nemotron3DiarizationForAudioFrameClassification]]

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

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

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

**パラメータ:**

config ([Nemotron3DiarizationConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

Streaming Sortformer話者分離モデル: スペクトログラムの各フレームについて、最初に検出された順序で最大`config.head_config.num_speakers`人の話者の活動を予測します。音声はチャンク単位で処理され、各チャンクは数フレームの先行フレームと、[Nemotron3DiarizationSpeakerCache](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationSpeakerCache)に保持されるArrival-Order Speaker CacheおよびFIFOキューに注意を払います。録音全体はforward自体によってチャンク分割されます（オフラインモード）。ストリームは、forwardごとに1チャンクずつ投入されます（ストリーミングモード）。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

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

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

**パラメータ:**

input_features (`torch.Tensor`、shape `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用して取得できます。詳細は `NemotronAsrStreamingFeatureExtractor.__call__()` を参照してください（[Nemotron3DiarizationProcessor](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor) は音声の処理に [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) を使用します）。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

speaker_cache (`Nemotron3DiarizationSpeakerCache`, *任意*) : 同一オーディオストリームの前チャンクの forward によって返されるストリーミング状態。

num_lookahead_frames (`int`, *optional*) : ストリーミングモード: 入力末尾の、ルックアヘッド専用のエンコーダーフレーム数です。これらのフレームはアテンションの対象となりますが、そのlogitsは返されず、次のチャンクを開くためFIFOキューには追加されません。[Nemotron3DiarizationProcessor](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationProcessor)は、セッションの最後のチャンクを除くすべてのチャンクに対してこれを設定します。これらの引数と`num_lookback_frames`がモードを選択します。ストリーミングモード、1回のforwardで1チャンク: `num_lookahead_frames`または`num_lookback_frames`が指定されている場合（最初のチャンクは`speaker_cache`を作成し、その後のチャンクはそれを受け取る）、または`speaker_cache`のみが指定されている場合（セッションの最後のチャンク、ルックアヘッドなし）。ルックバックとルックアヘッドのフレームを除いた入力が、長さに関係なく1チャンクとなり、`config.streaming_config`でサイズが決められたFIFOキューに全体としてプッシュされます。オフラインモード、どちらも指定されていない場合: 入力は録音全体であり、forwardによって`config.chunk_length`のエンコーダーフレームからなるチャンクに分割されます。各チャンクは、先行するチャンクから最大`config.chunk_left_context`のルックバックフレームと、後続のチャンクから最大`config.chunk_right_context`のルックアヘッドフレームを使用し、`config.fifo_length`でサイズが決められたFIFOキューを使用します。キャッシュは返されません。

num_lookback_frames (`int`, *optional*) : ストリーミングモード: 入力における、先行エンコーダーフレームの数。これらはルックバック専用であり、`speaker_cache`のフレームの上に、このチャンクより前に供給された直前のチャンクの末尾が再度配置されます。これらのフレームにはアテンションが適用されますが、そのlogitsは返されず、FIFOキューにも再び追加されません。デフォルト値は0です。

**戻り値:** [Nemotron3DiarizationOutput](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput) または `tuple(torch.Tensor)`

`torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）または [Nemotron3DiarizationOutput](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationOutput)。設定（[Nemotron3DiarizationConfig](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationConfig)）と入力に応じて、さまざまな要素で構成されます。

[Nemotron3DiarizationForAudioFrameClassification](/docs/transformers/main/ja/model_doc/nemotron3_diarization#transformers.Nemotron3DiarizationForAudioFrameClassification)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **logits** (`torch.Tensor`、形状 `(batch_size, num_frames, config.head_config.num_speakers)`) -- スペクトログラムのフレームレートでの、フレームごとの話者アクティビティの logits。`logits.sigmoid()` は、各フレームで各話者がアクティブである確率を返します。話者は、音声内で最初に検出された順序で並べられています。
- **hidden_states** (`tuple[torch.Tensor, ...]`、*optional*、`output_hidden_states=True` の場合に返されます) -- チャンク順に並べられた、各チャンクのエンコーダーの隠れ状態です。エンコーダーはチャンクごとに1回実行されるため、このタプルにはチャンクごとに`config.audio_config.num_hidden_layers + 1`個のテンソルが含まれます。シーケンス長は、キャッシュおよびルックアヘッドフレームを含むチャンクの長さに等しくなります。
- **attentions** (`tuple[torch.Tensor, ...]`、*optional*、`output_attentions=True` の場合に返されます) -- チャンク順に並べられた各チャンクのエンコーダーアテンション重み。各チャンクにつき`config.audio_config.num_hidden_layers`個のテンソル。
- **speaker_cache** (`Nemotron3DiarizationSpeakerCache`、*optional*、ストリーミングモードで返されます) -- 同一ストリームの次のオーディオチャンクを forward に渡すために使用する、更新されたストリーミング状態です。

例:

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