# Nemotron 3.5 ASR

## Ikhtisar

Nemotron 3.5 ASR adalah model pengenalan ucapan multibahasa dengan 600 juta parameter dari NVIDIA, yang dibangun untuk transkripsi berkualitas tinggi dalam pengaturan streaming latensi rendah maupun batch throughput tinggi, dengan penandaan dan kapitalisasi huruf secara native. Untuk streaming, model ini menawarkan ukuran chunk yang dapat dikonfigurasi—80ms, 160ms, 560ms, dan 1120ms—yang memungkinkan pengguna menyeimbangkan latensi terhadap akurasi sesuai kebutuhan aplikasi mereka. Arsitektur FastConformer-RNNT yang sadar cache menjadi inti dari kemampuan ini: berbeda dengan streaming berbuffer tradisional yang memproses ulang jendela audio yang tumpang tindih secara berulang, model ini hanya memproses setiap chunk baru yang masuk sambil menggunakan kembali konteks encoder yang di-cache dari chunk sebelumnya. Hal ini menghilangkan komputasi yang redundan, meningkatkan efisiensi secara signifikan, dan meminimalkan penundaan end-to-end tanpa mengorbankan akurasi, sehingga sangat cocok untuk beban kerja transkripsi real-time.

## Penggunaan

### Transkripsi offline

```python
from transformers import pipeline

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

> [!NOTE]
> Pipeline menggunakan prompt bahasa default (indeks 0, `en-US`). Untuk kondisioning bahasa eksplisit atau deteksi otomatis, berikan argumen `language` dari processor (lihat tab AutoModel).

Prompt bahasa dibuat oleh prosesor, sehingga bahasa ikut terbawa bersama input ke `generate`.

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

model_id = "nvidia/nemotron-3.5-asr-streaming-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,
)

# Condition on a known language ...
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate, language="en-US")
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))

# ... or let the model detect it and keep the emitted <xx-XX> language tag.
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate) # equiv to ..., language="auto"
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=False))
```

### Transkripsi streaming
> [!NOTE]
> Ini adalah fitur eksperimental dan API dapat berubah.

Untuk transkripsi real-time, audio dipecah menjadi potongan-potongan mengikuti:

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

model_id = "nvidia/nemotron-3.5-asr-streaming-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")

# The language prompt rides along on every chunk; use a locale (e.g. "de-DE") or "auto".
language = "en-US"

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,
    language=language,
    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,
            language=language,
            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()
```

#### Latensi streaming

Latensi diatur oleh `num_lookahead_tokens`, yaitu konteks perhatian kanan (lookahead, pada frame encoder yang disubsampling) yang ditunggu oleh setiap chunk sebelum chunk tersebut dikeluarkan. Nilai yang lebih besar memungkinkan setiap chunk melihat lebih banyak audio masa depan: akurasi yang lebih baik dengan biaya latensi yang lebih tinggi. Periksa trade-off yang didukung, pilih salah satu, dan baca kembali latensi yang dihasilkan:

```python
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-3.5-asr-streaming-0.6b")

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

# 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` menentukan ukuran chunk yang dihasilkan oleh processor, dan `num_lookahead_tokens` yang sesuai harus sampai ke `generate` (pada cuplikan di atas, nilainya diteruskan melalui `**inputs`/`**first_chunk_inputs`, yang membawa `num_lookahead_tokens`). Streaming `generate` akan memicu error jika parameter ini diabaikan.

## Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

#### transformers.Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

```python
transformers.Nemotron3_5AsrConfig(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 = 13088, 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 = 13087, num_prompts: int = 128, prompt_intermediate_size: int = 2048, default_prompt_id: int = 101)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/configuration_nemotron3_5_asr.py#L23)

**Parameter:**

is_encoder_decoder (`bool`, *opsional*, defaultnya `True`) : Apakah model digunakan sebagai encoder/decoder atau tidak.

vocab_size (`int`, *opsional*, default 13088) : Ukuran kosakata dari output jaringan gabungan (termasuk token kosong).

decoder_hidden_size (`int`, *opsional*, default 640) : Ukuran tersembunyi dari jaringan prediksi LSTM (`pred_hidden` dari NeMo).

num_decoder_layers (`int`, *opsional*, defaultnya 2) : Jumlah lapisan LSTM dalam jaringan prediksi.

hidden_act (`str`, *opsional*, defaultnya `"relu"`) : Aktivasi dalam jaringan gabungan.

max_symbols_per_step (`int`, *opsional*, default 10) : Jumlah maksimum simbol non-kosong yang dihasilkan per langkah waktu encoder selama dekodean serakah.

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *opsional*) : Objek konfigurasi atau kamus dari encoder. Langsung menggunakan [NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig), karena encoder-nya identik dengan milik `NemotronAsrStreaming`.

pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata.

blank_token_id (`int`, *opsional*, default 13087) : ID token kosong untuk dekode RNN-T.

num_prompts (`int`, *opsional*, default 128) : Jumlah slot prompt bahasa. Bahasa target dikodekan sebagai vektor one-hot dengan ukuran ini, disebarkan di sepanjang sumbu waktu encoder, dan digabungkan dengan output encoder sebelum MLP fusi `prompt_kernel`.

prompt_intermediate_size (`int`, *opsional*, default 2048) : Ukuran tersembunyi dari MLP fusi `prompt_kernel` (`Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)`).

default_prompt_id (`int`, *opsional*, default 101) : Indeks prompt yang digunakan untuk mengondisikan model ketika `prompt_ids` tidak diberikan. Default ke slot deteksi bahasa `auto` (indeks 101 dalam kamus prompt NeMo), sesuai dengan default NeMo `target_lang="auto"`: model mendeteksi bahasanya sendiri dan mengeluarkan tag `<xx-XX>`.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Nemotron3_5AsrForRNNT. Kelas ini digunakan untuk membuat instans model Nemotron 5 Asr sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [nvidia/nemotron-3.5-asr-streaming-0.6b](https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b)

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

Contoh:
```python
>>> from transformers import Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

>>> configuration = Nemotron3_5AsrConfig()
>>> model = Nemotron3_5AsrForRNNT(configuration)
>>> configuration = model.config
```

## Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

#### transformers.Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

```python
transformers.Nemotron3_5AsrProcessor(feature_extractor, tokenizer, blank_token = '<blank>', decoder_type = None, supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None, prompt_dictionary = None, num_prompts = 128)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L171)

**Parameter:**

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

tokenizer (`ParakeetTokenizer`) : Tokenizer adalah input yang wajib.

blank_token (`str`, *opsional*, defaultnya `"<blank>"`) : Token kosong untuk dekode RNN-T.

decoder_type (`str`, *opsional*) : Mode emisi decoding/timestamp (mis. `"ctc"`, `"rnnt"`, `"tdt"`). Jika `None`, tipe decoder disimpulkan secara otomatis untuk kompatibilitas mundur.

supported_num_lookahead_tokens (`list[int]`, *opsional*) : Konteks perhatian kanan yang didukung (lookahead, pada frame encoder yang disubsampling), mencerminkan `NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens`. Digunakan untuk memvalidasi `streaming_latency_ms` dan untuk menurunkan `num_lookahead_tokens` yang dikembalikan.

default_num_lookahead_tokens (`int`, *opsional*) : Konteks kanan yang digunakan ketika `streaming_latency_ms` tidak diberikan. Secara default, menggunakan entri pertama dari `supported_num_lookahead_tokens`.

prompt_dictionary (`dict[str, int]`, *opsional*) : Pemetaan dari string bahasa target (mis. `"en-US"`, `"de-DE"`, kode polos `"de"`, atau `"auto"`) ke indeks prompt-nya. Nilainya secara default mengikuti kamus prompt dari checkpoint NeMo.

num_prompts (`int`, *opsional*, default 128) : Jumlah slot prompt bahasa (ukuran vektor prompt one-hot), mencerminkan `Nemotron3_5AsrConfig.num_prompts`.

Membangun Nemotron3_5AsrProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[Nemotron3_5AsrProcessor](/docs/transformers/v5.23.0/id/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrProcessor) menyediakan semua fungsionalitas dari [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) dan [ParakeetTokenizer](/docs/transformers/v5.23.0/id/model_doc/parakeet#transformers.ParakeetTokenizer). Lihat [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) dan [~ParakeetTokenizer](/docs/transformers/v5.23.0/id/model_doc/parakeet#transformers.ParakeetTokenizer) untuk informasi lebih lanjut.

#### decode[[transformers.Nemotron3_5AsrProcessor.decode]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L322)

Teruskan argumen ke [decode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) dan proses pascameterai waktu tingkat token (jika `durations` disediakan) seperti pada pustaka NeMo.

#### set_num_lookahead_tokens[[transformers.Nemotron3_5AsrProcessor.set_num_lookahead_tokens]]

```python
set_num_lookahead_tokens(num_lookahead_tokens: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/processing_nemotron3_5_asr.py#L380)

Pilih konteks perhatian yang tepat (lookahead, pada frame encoder yang disubsampling) yang digunakan untuk streaming.

Mengatur `default_num_lookahead_tokens`, sehingga setiap properti streaming turunan (`num_mel_frames_first_audio_chunk`, `num_mel_frames_per_audio_chunk`, `num_samples_first_audio_chunk`, `num_samples_per_audio_chunk`) diturunkan ulang dari nilai baru. `num_lookahead_tokens` harus salah satu dari `supported_num_lookahead_tokens`.

Lewatkan `num_lookahead_tokens` yang sama ke `model.generate` agar konteks kanan perhatian yang digunakan dalam forward sesuai dengan ukuran chunk yang dihasilkan di sini; jika tidak, `generate` streaming akan memicu error.

## Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

#### transformers.Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

```python
transformers.Nemotron3_5AsrRNNTOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, decoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L46)

**Parameter:**

last_hidden_state (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) : Urutan hidden-states pada output dari lapisan terakhir model.

pooler_output (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) : Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.

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

attentions (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

loss (`torch.Tensor`, *opsional*, dikembalikan saat `labels` disediakan) : kerugian transducer RNN-T.

logits (`torch.Tensor` dengan bentuk `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) : Skor jaringan gabungan di atas kosakata ditambah simbol kosong, untuk setiap pasangan frame encoder/decoder.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *opsional*) : Cache LSTM decoder yang diperbarui. Dimanfaatkan pada prediksi kosong untuk melewati langkah LSTM.

encoder_past_key_values (`Cache`, *optional*) : Updated encoder attention K/V sliding-window cache, returned when encoding audio with `use_cache=True` (cache-aware streaming). Pass it to the next chunk's forward.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *opsional*) : Cache streaming conv terpadu yang diperbarui (subsampling Conv2d + conformer depthwise Conv1d), dikembalikan saat meng-encode audio dengan `use_cache=True`. Teruskan ke forward chunk berikutnya.

## Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

#### transformers.Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

```python
transformers.Nemotron3_5AsrForRNNT(config: Nemotron3_5AsrConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L212)

**Parameter:**

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

Nemotron3_5Asr Encoder dengan kepala RNN-T (Recurrent Neural Network Transducer) dan kondisioning prompt language-ID.

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

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

#### forward[[transformers.Nemotron3_5AsrForRNNT.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.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutputWithPooling | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, prompt_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/modeling_nemotron3_5_asr.py#L269)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan `feature_extractor_class`. Lihat `feature_extractor_class.__call__` untuk detailnya (`processor_class` menggunakan `feature_extractor_class` untuk memproses audio).

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

decoder_input_ids (`torch.LongTensor` dengan bentuk `(batch_size, 1)`, *opsional*) : ID token input decoder untuk inferensi satu langkah.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *opsional*) : Cache LSTM decoder. Dimanfaatkan kembali pada prediksi kosong untuk melewati langkah LSTM.

use_decoder_cache (`bool`, *opsional*) : Apakah akan mengalokasikan dan menggunakan cache decoder ketika tidak ada yang disediakan.

encoder_outputs (`tuple(torch.Tensor)`, *opsional*) : Output encoder yang sudah dihitung sebelumnya (last_hidden_state, pooler_output, ...).

labels (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada di `[0, ..., config.vocab_size]` atau -100 (lihat docstring `input_ids`). Token dengan indeks yang disetel ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label di `[0, ..., config.vocab_size]`.

num_lookahead_tokens (`int`, *opsional*) : Konteks perhatian kanan (lookahead, pada frame encoder yang disubsampling) yang diteruskan ke encoder. Nilainya secara default adalah `config.encoder_config.default_num_lookahead_tokens`.

prompt_ids (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Indeks prompt bahasa untuk kondisioning ID bahasa. Dihasilkan oleh prosesor dari `language`. Diubah menjadi one-hot broadcast yang dikonsumsi oleh `prompt_projector`.

**Mengembalikan:** [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/id/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) atau `tuple(torch.Tensor)`

Sebuah [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/id/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi (`None`) dan input.

Metode forward dari [Nemotron3_5AsrForRNNT](/docs/transformers/v5.23.0/id/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrForRNNT) menimpa metode khusus `__call__`.

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

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **loss** (`torch.Tensor`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss transducer RNN-T.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) -- Skor jaringan gabungan atas kosakata ditambah simbol kosong, untuk setiap pasangan frame encoder/decoder.
- **decoder_cache** (`Nemotron3_5AsrRNNTDecoderCache`, *opsional*) -- Cache LSTM decoder yang diperbarui. Dimanfaatkan kembali pada prediksi kosong untuk melewati langkah LSTM.
- **encoder_past_key_values** (`Cache`, *opsional*) -- Perbarui cache sliding-window K/V untuk perhatian encoder, dikembalikan saat mengkodekan audio dengan `use_cache=True` (streaming yang sadar cache). Sampaikan ke forward chunk berikutnya.
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *opsional*) -- Cache streaming conv terpadu yang diperbarui (subsampling Conv2d + conformer depthwise Conv1d), dikembalikan saat meng-encode audio dengan `use_cache=True`. Teruskan ke forward chunk berikutnya.

Contoh:

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

>>> model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5AsrForRNNT.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"], language="en-US")
>>> outputs = model(**inputs)
```

#### generate[[transformers.Nemotron3_5AsrForRNNT.generate]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron3_5_asr/generation_nemotron3_5_asr.py#L25)

