# Nemotron 3.5 ASR

## Tổng quan

Nemotron 3.5 ASR là mô hình nhận dạng giọng nói đa ngôn ngữ với 600 triệu tham số từ NVIDIA, được xây dựng cho việc chuyển văn bản chất lượng cao trong cả các thiết lập streaming độ trễ thấp và batch thông lượng cao, với dấu câu và chữ hoa bản địa. Đối với streaming, nó cung cấp các kích thước chunk có thể cấu hình—80ms, 160ms, 560ms và 1120ms, cho phép người dùng đánh đổi giữa độ trễ và độ chính xác để phù hợp với ứng dụng của họ. Kiến trúc FastConformer-RNNT nhận thức bộ nhớ đệm của nó là trung tâm của khả năng này: khác với streaming có bộ đệm truyền thống, vốn xử lý lại lặp đi lặp lại các cửa sổ âm thanh chồng chéo, mô hình chỉ xử lý mỗi chunk mới đến trong khi tái sử dụng ngữ cảnh encoder được lưu trong bộ nhớ đệm từ các chunk trước. Điều này loại bỏ các phép tính dư thừa, cải thiện đáng kể hiệu quả và giảm thiểu độ trễ đầu-cuối mà không hy sinh độ chính xác, khiến nó rất phù hợp với các tác vụ chuyển văn bản thời gian thực.

## Cách sử dụng

### Chuyển văn bản từ giọng nói 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 sử dụng prompt ngôn ngữ mặc định (chỉ số 0, `en-US`). Để điều kiện hóa ngôn ngữ rõ ràng hoặc phát hiện tự động, hãy truyền đối số `language` của processor (xem tab AutoModel).

Prompt ngôn ngữ được tạo bởi bộ xử lý, do đó ngôn ngữ đi cùng các đầu vào vào `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))
```

### Chuyển văn bản trực tiếp
> [!NOTE]
> Đây là một tính năng thử nghiệm và API có thể thay đổi.

Đối với chuyển văn bản thời gian thực, âm thanh được chia thành các đoạn theo:

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

#### Độ trễ phát trực tiếp

Độ trễ được xác định bởi `num_lookahead_tokens`, tức là ngữ cảnh chú ý phía trước (lookahead, trong các khung encoder được lấy mẫu con) mà mỗi khối chờ đợi trước khi được phát ra. Giá trị lớn hơn cho phép mỗi khối nhìn thấy nhiều âm thanh tương lai hơn: độ chính xác tốt hơn với cái giá là độ trễ cao hơn. Kiểm tra các đánh đổi được hỗ trợ, chọn một phương án và đọc lại độ trễ kết quả:

```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` xác định kích thước các khối mà bộ xử lý phát ra, và `num_lookahead_tokens` tương ứng phải được truyền đến `generate` (trong đoạn mã ở trên, nó được truyền qua `**inputs`/`**first_chunk_inputs`, vốn mang theo `num_lookahead_tokens`). Chế độ streaming của `generate` sẽ gây ra lỗi nếu tham số này bị bỏ qua.

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

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

**Tham số:**

is_encoder_decoder (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có được sử dụng như một bộ mã hóa/giải mã hay không.

vocab_size (`int`, *optional*, mặc định là 13088) : Kích thước từ vựng của đầu ra mạng kết hợp (bao gồm token blank).

decoder_hidden_size (`int`, *tuỳ chọn*, mặc định là 640) : Kích thước ẩn của mạng dự đoán LSTM (`pred_hidden` của NeMo).

num_decoder_layers (`int`, *tuỳ chọn*, mặc định là 2) : Số lớp LSTM trong mạng dự đoán.

hidden_act (`str`, *tùy chọn*, mặc định là `"relu"`) : Hàm kích hoạt trong mạng liên hợp.

max_symbols_per_step (`int`, *tuỳ chọn*, mặc định là 10) : Số lượng tối đa các ký hiệu không trống được phát ra cho mỗi bước thời gian của bộ mã hóa trong quá trình giải mã tham lam.

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *optional*) : Đối tượng cấu hình hoặc từ điển của encoder. Tái sử dụng trực tiếp [NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig), vì encoder giống hệt với của `NemotronAsrStreaming`.

pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

blank_token_id (`int`, *tuỳ chọn*, mặc định là 13087) : ID của token trống cho việc giải mã RNN-T.

num_prompts (`int`, *optional*, mặc định là 128) : Số lượng slot cho prompt ngôn ngữ. Ngôn ngữ đích được mã hóa dưới dạng vector one-hot có kích thước này, được broadcast dọc theo trục thời gian của encoder và nối với đầu ra của encoder trước khi đưa vào MLP kết hợp `prompt_kernel`.

prompt_intermediate_size (`int`, *tuỳ chọn*, mặc định là 2048) : Kích thước ẩn của MLP kết hợp `prompt_kernel` (`Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)`).

default_prompt_id (`int`, *optional*, mặc định là 101) : Chỉ số prompt được sử dụng để điều kiện hóa mô hình khi `prompt_ids` không được cung cấp. Mặc định là ô phát hiện ngôn ngữ `auto` (chỉ số 101 trong từ điển prompt của NeMo), khớp với mặc định `target_lang="auto"` của NeMo: mô hình tự phát hiện ngôn ngữ và phát ra thẻ `<xx-XX>`.

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

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

Ví dụ:
```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)
```

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

**Tham số:**

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

tokenizer (`ParakeetTokenizer`) : Tokenizer là đầu vào bắt buộc.

blank_token (`str`, *tùy chọn*, mặc định là `"<blank>"`) : Token trống cho giải mã RNN-T.

decoder_type (`str`, *tùy chọn*) : Chế độ giải mã/phát timestamp (ví dụ `"ctc"`, `"rnnt"`, `"tdt"`). Nếu là `None`, loại bộ giải mã sẽ được suy luận tự động để đảm bảo tương thích ngược.

supported_num_lookahead_tokens (`list[int]`, *tuỳ chọn*) : Các ngữ cảnh chú ý bên phải được hỗ trợ (lookaheads, trong các khung encoder được lấy mẫu con), phản ánh `NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens`. Được dùng để xác thực `streaming_latency_ms` và để suy ra `num_lookahead_tokens` được trả về.

default_num_lookahead_tokens (`int`, *optional*) : Ngữ cảnh bên phải được sử dụng khi `streaming_latency_ms` không được cung cấp. Mặc định là mục đầu tiên của `supported_num_lookahead_tokens`.

prompt_dictionary (`dict[str, int]`, *tùy chọn*) : Ánh xạ từ chuỗi ngôn ngữ đích (ví dụ `"en-US"`, `"de-DE"`, mã đơn thuần `"de"`, hoặc `"auto"`) đến chỉ số prompt của nó. Mặc định là từ điển prompt của checkpoint NeMo.

num_prompts (`int`, *optional*, mặc định là 128) : Số lượng khe prompt ngôn ngữ (kích thước của vector prompt one-hot), phản ánh `Nemotron3_5AsrConfig.num_prompts`.

Tạo một Nemotron3_5AsrProcessor, đóng gói một bộ trích xuất đặc trưng và một bộ phân từ thành một bộ xử lý duy nhất.

[Nemotron3_5AsrProcessor](/docs/transformers/v5.23.0/vi/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrProcessor) cung cấp đầy đủ các chức năng của [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) và [ParakeetTokenizer](/docs/transformers/v5.23.0/vi/model_doc/parakeet#transformers.ParakeetTokenizer). Xem [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) và [~ParakeetTokenizer](/docs/transformers/v5.23.0/vi/model_doc/parakeet#transformers.ParakeetTokenizer) để biết thêm thông tin.

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

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

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

Truyền các đối số tới [decode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) và xử lý hậu kỳ các mốc thời gian ở cấp độ token (nếu `durations` được cung cấp) theo cách của thư viện NeMo.

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

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

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

Chọn ngữ cảnh chú ý (attention context) phù hợp (lookahead, trong các khung encoder được lấy mẫu con) được sử dụng cho streaming.

Đặt `default_num_lookahead_tokens`, để mọi thuộc tính streaming phái sinh (`num_mel_frames_first_audio_chunk`, `num_mel_frames_per_audio_chunk`, `num_samples_first_audio_chunk`, `num_samples_per_audio_chunk`) được suy ra lại từ giá trị mới. `num_lookahead_tokens` phải là một trong các giá trị của `supported_num_lookahead_tokens`.

Truyền cùng một `num_lookahead_tokens` cho `model.generate` để ngữ cảnh chú ý phía bên phải được sử dụng trong bước forward khớp với kích thước chunk được tạo ra ở đây; nếu không, `generate` dạng streaming sẽ gây ra lỗi.

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

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

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

pooler_output (`torch.Tensor` có shape `(batch_size, hidden_size)`) : Hidden-state của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý tiếp qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.  Hidden-states của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.

attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.  Trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

loss (`torch.Tensor`, *tùy chọn*, được trả về khi `labels` được cung cấp) : Mất (loss) của transducer RNN-T.

logits (`torch.Tensor` có shape `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) : Điểm của mạng liên hợp trên từ vựng cùng ký tự blank, cho mọi cặp khung encoder/decoder.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *tùy chọn*) : Bộ đệm LSTM của bộ giải mã đã được cập nhật. Được tái sử dụng trên các dự đoán trống để bỏ qua bước LSTM.

encoder_past_key_values (`Cache`, *optional*) : Bộ nhớ đệm trượt cửa sổ cho K/V của attention encoder đã được cập nhật, được trả về khi mã hóa âm thanh với `use_cache=True` (streaming nhận thức bộ nhớ đệm). Truyền nó vào bước forward của chunk tiếp theo.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *tùy chọn*) : Bộ đệm conv streaming thống nhất đã cập nhật (Conv2d subsampling + Conv1d depthwise conformer), được trả về khi mã hóa âm thanh với `use_cache=True`. Truyền nó vào bước forward của khối tiếp theo.

## Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

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

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

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

**Tham số:**

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

Nemotron3_5Asr Encoder với đầu RNN-T (Recurrent Neural Network Transducer) và điều kiện prompt nhận dạng ngôn ngữ.

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

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

#### forward[[transformers.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'>)
```

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

**Tham số:**

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

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

decoder_input_ids (`torch.LongTensor` có hình dạng `(batch_size, 1)`, *tùy chọn*) : Các id token đầu vào của bộ giải mã cho suy luận một bước.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *tùy chọn*) : Bộ đệm LSTM của bộ giải mã. Được tái sử dụng ở các dự đoán trống để bỏ qua bước LSTM.

use_decoder_cache (`bool`, *tùy chọn*) : Có cấp phát và sử dụng bộ đệm giải mã (decoder cache) khi không có bộ đệm nào được cung cấp hay không.

encoder_outputs (`tuple(torch.Tensor)`, *tùy chọn*) : Đầu ra của bộ mã hóa đã được tính trước (last_hidden_state, pooler_output, ...).

labels (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có che (masked language modeling loss). Chỉ số phải nằm trong `[0, ..., config.vocab_size]` hoặc -100 (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`.

num_lookahead_tokens (`int`, *optional*) : Ngữ cảnh chú ý phía bên phải (lookahead, trong các khung encoder được lấy mẫu con) được chuyển tiếp đến encoder. Mặc định là `config.encoder_config.default_num_lookahead_tokens`.

prompt_ids (`torch.LongTensor` có shape `(batch_size,)`, *tùy chọn*) : Các chỉ số prompt ngôn ngữ cho việc điều kiện hóa theo ID ngôn ngữ. Được tạo ra bởi processor từ `language`. Được chuyển thành one-hot broadcast để `prompt_projector` sử dụng.

**Trả về:** [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/vi/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) hoặc `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

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

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **loss** (`torch.Tensor`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Mất (loss) của transducer RNN-T.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) -- Điểm số của mạng liên hợp trên bảng từ vựng cùng ký tự blank, cho mọi cặp khung encoder/decoder.
- **decoder_cache** (`Nemotron3_5AsrRNNTDecoderCache`, *optional*) -- Cache LSTM của decoder đã được cập nhật. Được tái sử dụng trên các dự đoán trống để bỏ qua bước LSTM.
- **encoder_past_key_values** (`Cache`, *tuỳ chọn*) -- Bộ đệm cửa sổ trượt K/V của attention encoder đã được cập nhật, được trả về khi mã hóa âm thanh với `use_cache=True` (streaming nhận thức bộ đệm). Truyền nó vào bước forward của chunk tiếp theo.
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *optional*) -- Bộ đệm conv streaming thống nhất đã cập nhật (subsampling Conv2d + conformer depthwise Conv1d), được trả về khi mã hóa âm thanh với `use_cache=True`. Truyền nó vào bước forward của khối tiếp theo.

Ví dụ:

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

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

