# Nemotron ASR ストリーミング

## 概要

Nemotron ASR Streaming は、NVIDIA による 6 億パラメータの英語音声認識モデルです。低レイテンシのストリーミング環境と高スループットのバッチ環境の両方で高品質な文字起こしを実現するように設計されており、句読点と大文字の自動付与をネイティブでサポートしています。ストリーミング処理では、80ms、160ms、560ms、1120ms の設定可能なチャンクサイズを提供し、アプリケーションの要件に応じてレイテンシと精度のトレードオフを調整できます。この機能の中心となるのは、キャッシュ対応の FastConformer-RNNT アーキテクチャです。従来のバッファリング型ストリーミングでは重複する音声ウィンドウを繰り返し再処理しますが、このモデルは新しい入力のチャンクのみを処理し、以前のチャンクからキャッシュされたエンコーダのコンテキストを再利用します。これにより冗長な計算が排除され、効率が大幅に向上し、精度を犠牲にすることなくエンドツーエンドの遅延を最小限に抑えるため、リアルタイム文字起こしのワークロードに最適です。

## 使用方法

### オフライン文字起こし

```python
from transformers import pipeline

pipe = pipeline(
    "automatic-speech-recognition",
    model="nvidia/nemotron-speech-streaming-en-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
```

```python
from transformers import AutoModelForRNNT, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3",
    sampling_rate=processor.feature_extractor.sampling_rate,
)

inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

### ストリーミング文字起こし
> [!NOTE]
> これは実験的な機能であり、APIは変更される可能性があります。

リアルタイム文字起こしでは、音声は次のルールに従ってチャンクに分割されます。

```python
from threading import Thread
from transformers import AutoModelForRNNT, AutoProcessor, TextIteratorStreamer
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

processor.set_num_lookahead_tokens(6)
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/obama.mp3",
    sampling_rate=sampling_rate,
)

first_chunk_inputs = processor(
    audio[: processor.num_samples_first_audio_chunk],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=True,
    return_tensors="pt",
)
first_chunk_inputs = first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features[:, : processor.num_mel_frames_first_audio_chunk, :]

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    n_fft = processor.feature_extractor.n_fft

    start_idx = mel_frame_idx * hop_length - n_fft // 2
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
            return_tensors="pt",
        )
        inputs = inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.num_mel_frames_per_audio_chunk
        start_idx = mel_frame_idx * hop_length - n_fft // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True)
generate_kwargs = {
    **first_chunk_inputs,
    "input_features": input_features_generator(),
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)
thread.join()
```

#### ストリーミングのレイテンシ

レイテンシは`num_lookahead_tokens`によって設定されます。これは、各チャンクが出力される前に待機する右側のアテンションコンテキスト（サブサンプリングされたエンコーダーフレームにおけるルックアヘッド）です。値を大きくすると、各チャンクがより多くの将来のオーディオを参照できるようになり、レイテンシが高くなる代わりに精度が向上します。サポートされているトレードオフを確認し、1つを選択して、結果として得られるレイテンシを読み取ります。

```python
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-speech-streaming-en-0.6b")

# Each supported `num_lookahead_tokens` mapped to its streaming latency in milliseconds:
print(processor.supported_streaming_latencies_ms)
# {13: 1120, 6: 560, 1: 160, 0: 80}

# Select a right attention context (this also re-derives the streaming chunk sizes used above):
processor.set_num_lookahead_tokens(6)

# Latency of the current selection:
print(processor.streaming_latency_ms)
# 560
```

`set_num_lookahead_tokens` はプロセッサが出力するチャンクのサイズを決定し、対応する `num_lookahead_tokens` は `generate` に到達する必要があります（上記のスニペットでは、`num_lookahead_tokens` を保持する `**inputs`/`**first_chunk_inputs` を経由して渡されます）。ストリーミング `generate` では、これが省略されている場合、例外が発生します。

## NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

#### transformers.NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

```python
transformers.NemotronAsrStreamingConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 1025, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0, blank_token_id: int = 1024)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L120)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

vocab_size (`int`、*任意*、デフォルトは`1025`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

decoder_hidden_size (`int`、*optional*、デフォルトは 640) : LSTM 予測ネットワークの隠れ層サイズ（NeMo の `pred_hidden`）です。ジョイントネットワークは、エンコーダーとデコーダーの両方の出力をこのサイズに射影します（NeMo の `joint_hidden`。既知のチェックポイントはすべてこれを `pred_hidden` と等しく設定しています）。

num_decoder_layers (`int`、*optional*、デフォルトは 2) : 予測ネットワークにおける LSTM レイヤーの数。

hidden_act (`str`、*任意*、デフォルトは`"relu"`) : 結合ネットワークにおける活性化関数。

max_symbols_per_step (`int`、*optional*、デフォルトは 10) : グリーディーデコーディング中に、エンコーダの各タイムステップで出力される空白でない記号の最大数。

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *任意*) : エンコーダーの設定オブジェクトまたは辞書。

pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。

blank_token_id (`int`、*任意*、デフォルトは 1024) : 空白トークン ID。RNN-T では `pad_token_id` と異なります。

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

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

例:
```python
>>> from transformers import NemotronAsrStreamingForRNNT, NemotronAsrStreamingConfig

>>> # Initializing a NemotronAsrStreaming RNN-T configuration
>>> configuration = NemotronAsrStreamingConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingForRNNT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

#### transformers.NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

```python
transformers.NemotronAsrStreamingEncoderConfig(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 = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02, sliding_window: int = 71, default_num_lookahead_tokens: int = 13)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**パラメータ:**

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

num_hidden_layers (`int`、*optional*、デフォルトは `24`) : Transformer デコーダーの隠れ層の数。

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

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

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

attention_bias (`bool`, *任意*, デフォルトは `True`) : セルフアテンションにおいて、クエリ、キー、バリュー、出力の投影層にバイアスを使用するかどうか。

convolution_bias (`bool`, *任意*, デフォルトは `True`) : conformer の畳み込みモジュールの畳み込みでバイアスを使用するかどうか。

conv_kernel_size (`int`, *optional*, デフォルトは 9) : Conformer ブロック内の畳み込み層のカーネルサイズ。

subsampling_factor (`int`, *optional*, デフォルトは 8) : 入力シーケンスをサブサンプリングする倍率です。

subsampling_conv_channels (`int`、*任意*、デフォルトは 256) : サブサンプリング畳み込み層のチャネル数。

num_mel_bins (`int`、*optional*、デフォルトは 80) : mel 特徴の数量。

subsampling_conv_kernel_size (`int`、*optional*、デフォルトは 3) : サブサンプリング畳み込み層のカーネルサイズ。

subsampling_conv_stride (`int`、*optional*、デフォルトは 2) : サブサンプリング畳み込み層のストライドです。

dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

dropout_positions (`float`、*任意*、デフォルトは 0.0) : 入力シーケンスの位置に対する dropout 率です。

layerdrop (`Union[float, int]`、*任意*、デフォルトは`0.1`) : LayerDrop の確率です。詳細については、[LayerDrop の論文](see https://huggingface.co/papers/1909.11556)を参照してください。

activation_dropout (`Union[float, int]`、*任意*、デフォルトは `0.1`) : 全結合層内の活性化の dropout 率。

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

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

scale_input (`bool`、*任意*、デフォルトは`True`) : 入力埋め込みをスケーリングするかどうか。

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

sliding_window (`int`、*optional*、デフォルト値は 71) : K/V 注意スライディングウィンドウのサイズ（サブサンプリングされたエンコーダーフレーム単位）です。`left_context + 1`（現在のフレームと左コンテキスト）に等しく、左の注意コンテキストは `sliding_window - 1` となります。これはサポートされているすべてのルックアヘッドで同じです。

default_num_lookahead_tokens (`int`、*optional*、デフォルト値は 13) : forward に何も渡されない場合に使用される、右側の注意コンテキスト（サブサンプリングされたエンコーダーフレームにおける lookahead）です。モデルが学習時に使用したサポート対象のセットは、[NemotronAsrStreamingProcessor](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) に格納されています。

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

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

例:
```python
>>> from transformers import NemotronAsrStreamingEncoder, NemotronAsrStreamingEncoderConfig

>>> # Initializing a `NemotronAsrStreamingEncoder` configuration
>>> configuration = NemotronAsrStreamingEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingEncoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

#### transformers.NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

```python
transformers.NemotronAsrStreamingFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, mel_filters_dtype = 'float32', **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L41)

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 80) : 抽出された特徴量の次元数。

sampling_rate (`int`、*optional*、デフォルトは 16000) : 音声ファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 単位）。

hop_length (`int`, *optional*, デフォルトは 160) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。

n_fft (`int`, *任意*, デフォルトは 512) : フーリエ変換のサイズ。

win_length (`int`、*任意*、デフォルトは 400) : STFT 計算のウィンドウ長です。

preemphasis (`float`、*optional*、デフォルトは 0.97) : 事前強調フィルターの係数です。0.0 は事前強調フィルターを適用しないことを意味します。

padding_value (`float`、*optional*、デフォルト値は 0.0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。

mel_filters_dtype (`str`、*任意*、デフォルトは`"float32"`) : 保存されるメルフィルタバンクとSTFTウィンドウの精度です。一部のチェックポイントでは、これらの定数が低減された精度（Nemotron 3.5 Transcribeの場合は`"bfloat16"`）で保持されています。この場合、特徴量が計算される際にフィルタバンクとウィンドウは該当するdtypeに丸められ、ログメル特徴量が元のフロントエンドと一致するようになります。スペクトログラム自体は常にfloat32で計算されます。

NemotronAsrStreaming の特徴量抽出器を構築します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

このクラスは、`Short Time Fourier Transform` のカスタムな numpy 実装を使用して、生音声からメルフィルタバンク特徴量を抽出します。この実装は、PyTorch の `torch.stft` と同等の結果を出力するようになっています。

## NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

#### transformers.NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

```python
transformers.NemotronAsrStreamingProcessor(feature_extractor, tokenizer, blank_token = '<blank>', supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L50)

**パラメータ:**

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

tokenizer (`ParakeetTokenizer`) : トークナイザーは必須の入力です。

blank_token (`str`、*任意*、デフォルトは`"<blank>"`) : RNN-Tデコーディング用のブランクトークン。

supported_num_lookahead_tokens (`list[int]`, *任意*) : モデルが学習時に使用した右側のアテンションコンテキスト（サブサンプリングされたエンコーダーフレームにおけるルックアヘッド）です。このセットの唯一の信頼できる情報源はプロセッサであり、`set_num_lookahead_tokens()` はこれに対して検証を行います。デフォルトでは、NeMo のキャッシュ対応セット `[13, 6, 1, 0]` が使用されます。

default_num_lookahead_tokens (`int`, *任意*) : ストリーミングチャンクのサイズを決定するために使用される右コンテキストであり、[__call__()](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__)によって出力されます。`set_num_lookahead_tokens()`で変更できます。デフォルトでは、`supported_num_lookahead_tokens`の最初のエントリが使用されます。

NemotronAsrStreamingProcessor を構築します。このクラスは、フィーチャーエクストラクターとトークナイザーを単一のプロセッサーにラップします。

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

#### __call__[[transformers.NemotronAsrStreamingProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], text: str | list[str] | list[list[str]] | None = None, sampling_rate: int | None = None, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.models.nemotron_asr_streaming.processing_nemotron_asr_streaming.NemotronAsrStreamingProcessorKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L85)

**パラメータ:**

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

text (`Union[str, list[str], list[list[str]]]`、*任意*) : エンコード対象のシーケンスまたはシーケンスのバッチです。各シーケンスは文字列、または文字列のリスト（プレトークナイズ済み文字列）であることができます。プレトークナイズ済み入力を渡す場合は、バッチ入力との曖昧さを避けるために `is_split_into_words=True` を設定してください。

sampling_rate (`int`, *optional*) : 入力オーディオのサンプリングレート（Hz）。これは、フィーチャーエクストラクターが想定するサンプリングレートと一致する必要があります（デフォルトは 16000 Hz）。指定された場合、プロセッサが想定するサンプリングレートと照合され、一致しない場合はエラーが発生します。指定されなかった場合、警告が発行され、デフォルトのサンプリングレートが使用されます。

is_streaming (`bool`、*任意*、デフォルトは`False`) : オーディオをストリーミングモードで処理するかどうか。`True`の場合、`is_first_audio_chunk`を使用して最初のチャンクとそれ以降のチャンクを区別しながら、オーディオをチャンク単位で渡すことができます。

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

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)

feature-extractor（および任意の tokenizer）の出力に、以下を追加したものです：

- **num_lookahead_tokens** -- 右側の注意コンテキスト（サブサンプリングされたエンコーダーフレームにおけるルックアヘッド）です。つまり、`default_num_lookahead_tokens`（`set_num_lookahead_tokens()`で設定）です。モデル/エンコーダーの forward（または `generate`）に渡します。Voxtral Realtime の `num_delay_tokens` の役割を担います。

#### decode[[transformers.NemotronAsrStreamingProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L169)

[decode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) に引数を転送し、NeMo ライブラリと同様に、`durations` が提供されている場合はトークンレベルのタイムスタンプを後処理します。

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

#### transformers.NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

```python
transformers.NemotronAsrStreamingEncoderModelOutput(last_hidden_state: typing.Optional[torch.FloatTensor] = None, pooler_output: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor, ...] | None = None, attentions: tuple[torch.FloatTensor, ...] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L325)

**パラメータ:**

last_hidden_state (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における hidden-states のシーケンス。

pooler_output (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) : 補助事前学習タスクに使用される層をさらに通して処理した後の、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次の文予測（分類）目的から学習されます。

hidden_states (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

attention_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : シーケンス圧縮後、パディングトークンのインデックスに対するアテンションの適用を回避するためのマスク。入力シーケンスの長さと異なる可能性があるため返されます。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、 - **マスクされる**トークンは 0。

past_key_values (`Cache`, *optional*) : エンコーダーからの更新されたアテンション K/V スライディングウィンドウキャッシュ。次のチャンク呼び出しに渡します。

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *任意*) : サブサンプリング用の Conv2d 層と conformer の depthwise Conv1d をサポートする、統合されたストリーミングキャッシュです。

`ParakeetEncoderModelOutput`を拡張し、オプションのストリーミングキャッシュを追加します。キャッシュは、`use_cache=True`の場合に、キャッシュ対応モデルでのみ設定されます。

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

#### transformers.NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

```python
transformers.NemotronAsrStreamingRNNTOutput(last_hidden_state: typing.Optional[torch.FloatTensor] = None, pooler_output: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor, ...] | None = None, attentions: tuple[torch.FloatTensor, ...] | None = None, loss: typing.Optional[torch.FloatTensor] = None, logits: typing.Optional[torch.FloatTensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_past_key_values (`Cache`、*任意*): `use_cache=True` でオーディオをエンコードする際に返される、更新されたエンコーダーアテンションの K/V スライディングウィンドウキャッシュ (キャッシュ対応ストリーミング) です。次のチャンクの forward に渡してください。padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`、*任意*): `use_cache=True` でオーディオをエンコードする際に返される、更新された統合ストリーミング conv キャッシュ (サブサンプリング Conv2d + conformer depthwise Conv1d) です。次のチャンクの forward に渡してください。

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

#### transformers.NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

```python
transformers.NemotronAsrStreamingEncoder(config: NemotronAsrStreamingEncoderConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L877)

**パラメータ:**

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

[Fast Conformerアーキテクチャ](https://huggingface.co/papers/2305.05084)をベースにしたNemotronAsrStreaming Encoderモデル。

このモデルは [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.NemotronAsrStreamingEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, output_attention_mask: bool = True, use_cache: bool | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L900)

**パラメータ:**

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は `feature_extractor_class` を使用して取得できます。詳細は `feature_extractor_class.__call__` を参照してください（`processor_class` は音声の処理に `feature_extractor_class` を使用します）。

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

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

past_key_values (`Cache`, *optional*) : キャッシュ対応ストリーミングアテンション用のスライディングウィンドウK/Vキャッシュ（`config.sliding_window`から構築された`DynamicCache`）。

output_attention_mask (`bool`、*任意*、デフォルトは`True`) : 出力のattention maskを返すかどうか。`attention_mask`が提供されている場合のみ有効です。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *任意*) : サブサンプリング用の Conv2d 層と conformer の depthwise Conv1d をサポートする、統合されたストリーミングキャッシュです。

num_lookahead_tokens (`int`, *optional*) : このフォワードパスにおける右側のアテンションコンテキスト（サブサンプリングされたエンコーダーフレームにおけるルックアヘッド）のオーバーライド。左コンテキスト `config.sliding_window - 1` と組み合わせて使用されます。デフォルト値は `config.default_num_lookahead_tokens` です。

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

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

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

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

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

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

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

例:

```python
>>> from transformers import AutoProcessor, NemotronAsrStreamingEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = NemotronAsrStreamingEncoder.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)
```

## NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

#### transformers.NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

```python
transformers.NemotronAsrStreamingForRNNT(config: NemotronAsrStreamingConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**パラメータ:**

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

RNN-T（Recurrent Neural Network Transducer）ヘッドを備えたNemotronAsrStreaming Encoder。

このモデルは [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.NemotronAsrStreamingForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**パラメータ:**

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は `feature_extractor_class` を使用して取得できます。詳細は `feature_extractor_class.__call__` を参照してください（`processor_class` は音声の処理に `feature_extractor_class` を使用します）。

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

decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, 1)`、*任意*) : 単一ステップ推論用のデコーダー入力トークンID。

decoder_cache (`NemotronAsrStreamingRNNTDecoderCache`、*任意*) : デコーダーLSTMキャッシュ。空白の予測時に再利用して、LSTMステップをスキップします。

use_decoder_cache (`bool`, *任意*) : デコーダキャッシュが提供されていない場合に、割り当てて使用するかどうかを指定します。

encoder_outputs (`NemotronAsrStreamingEncoderModelOutput`, *任意*) : 事前計算されたエンコーダーの出力 (last_hidden_state, pooler_output, ...)。

labels (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。

num_lookahead_tokens (`int`, *optional*) : エンコーダーに転送される右側のアテンションコンテキスト（サブサンプリングされたエンコーダーフレームにおけるルックアヘッド）。デフォルト値は`config.encoder_config.default_num_lookahead_tokens`です。

**戻り値:** [NemotronAsrStreamingRNNTOutput](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) または `tuple(torch.FloatTensor)`

`None`や入力に応じて、さまざまな要素で構成される、[NemotronAsrStreamingRNNTOutput](/docs/transformers/main/ja/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput)または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。

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

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

- **encoder_past_key_values** (`Cache`、*任意*) -- `use_cache=True` でオーディオをエンコードする際に返される、更新されたエンコーダーアテンションの K/V スライディングウィンドウキャッシュ（キャッシュ対応ストリーミング）。次のチャンクの forward に渡します。
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`、*optional*) -- 更新された統合ストリーミング conv キャッシュ（サブサンプリング Conv2d + conformer depthwise Conv1d）。`use_cache=True` でオーディオをエンコードする際に返されます。次のチャンクの forward に渡してください。

例:

```python
>>> from transformers import AutoProcessor, NemotronAsrStreamingForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = NemotronAsrStreamingForRNNT.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> outputs = model(**inputs)
```

#### generate[[transformers.NemotronAsrStreamingForRNNT.generate]]

```python
generate(inputs = None, generation_config = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/generation_nemotron_asr_streaming.py#L212)