# Nemotron ASR Streaming

## Tổng quan

Nemotron ASR Streaming là mô hình nhận dạng giọng nói tiếng Anh 600M 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ỏ tính toán 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-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))
```

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

#### Độ 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-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` 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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L120)

**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`, *tùy chọn*, mặc định là `1025`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

decoder_hidden_size (`int`, *optional*, mặc định là 640) : Kích thước ẩn của mạng dự đoán LSTM (`pred_hidden` của NeMo). Mạng kết hợp chiếu cả đầu ra của bộ mã hóa và bộ giải mã xuống kích thước này (`joint_hidden` của NeMo, mà tất cả các checkpoint đã biết đều đặt bằng `pred_hidden`).

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]`, *tùy chọn*) : Đối tượng cấu hình hoặc từ điển của bộ mã hóa.

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à 1024) : id của token trống. Khác với `pad_token_id` đối với RNN-T.

Đây là lớp cấu hình để lưu trữ cấu hình của một NemotronAsrStreamingForRNNT. Nó được sử dụng để khởi tạo một mô hình Nemotron Asr Streaming 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ủa [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-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 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `1024`) : Kích thước của các biểu diễn ẩn.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `24`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `8`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

intermediate_size (`int`, *tuỳ chọn*, mặc định là `4096`) : Kích thước của các biểu diễn MLP.

hidden_act (`str`, *tùy chọn*, mặc định là `silu`) : Hàm kích hoạt phi tuyến tính (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

attention_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng bias trong các lớp chiếu query, key, value và output trong quá trình tự chú ý hay không.

convolution_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng bias trong các phép convolution của module convolution trong conformer hay không.

conv_kernel_size (`int`, *optional*, mặc định là 9) : Kích thước kernel của các lớp tích chập trong khối Conformer.

subsampling_factor (`int`, *tuỳ chọn*, mặc định là 8) : Hệ số mà theo đó chuỗi đầu vào được lấy mẫu con.

subsampling_conv_channels (`int`, *tuỳ chọn*, mặc định là 256) : Số lượng kênh trong các lớp tích chập lấy mẫu con.

num_mel_bins (`int`, *tuỳ chọn*, mặc định là 80) : Số lượng đặc trưng mel.

subsampling_conv_kernel_size (`int`, *tuỳ chọn*, mặc định là 3) : Kích thước kernel của các lớp tích chập hạ mẫu.

subsampling_conv_stride (`int`, *tuỳ chọn*, mặc định là 2) : Bước nhảy (stride) của các lớp tích chập lấy mẫu con (subsampling).

dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ cho tất cả các lớp dropout.

dropout_positions (`float`, *tuỳ chọn*, mặc định là 0.0) : Tỷ lệ dropout cho các vị trí trong chuỗi đầu vào.

layerdrop (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất LayerDrop. Xem [bài báo LayerDrop](see https://huggingface.co/papers/1909.11556) để biết thêm chi tiết.

activation_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các kích hoạt bên trong lớp liên kết đầy đủ.

attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý.

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `5000`) : Độ dài tối đa của chuỗi mà mô hình này có thể được sử dụng.

scale_input (`bool`, *tùy chọn*, mặc định là `True`) : Có nên mở rộng các embedding đầu vào hay không.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

sliding_window (`int`, *optional*, mặc định là 71) : Kích thước của cửa sổ trượt chú ý K/V (tính theo các khung encoder đã lấy mẫu thưa). Giá trị này bằng `left_context + 1` (khung hiện tại cộng với ngữ cảnh bên trái), do đó ngữ cảnh chú ý bên trái là `sliding_window - 1` — giống nhau trên tất cả các lookahead được hỗ trợ.

default_num_lookahead_tokens (`int`, *optional*, mặc định là 13) : Bối cảnh chú ý bên phải (lookahead, trong các khung encoder được lấy mẫu con) được sử dụng khi không có giá trị nào được truyền vào forward. Tập hợp các giá trị được hỗ trợ mà mô hình đã được huấn luyện nằm trên [NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor).

Đây là lớp cấu hình để lưu trữ cấu hình của một NemotronAsrStreamingForRNNT. Nó được sử dụng để khởi tạo một mô hình Nemotron Asr Streaming 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ủa [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-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 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L40)

**Tham số:**

feature_size (`int`, *tuỳ chọn*, mặc định là 80) : Kích thước chiều của các đặc trưng đã trích xuất.

sampling_rate (`int`, *optional*, mặc định là 16000) : Tốc độ lấy mẫu (sampling rate) mà các tệp âm thanh nên được số hóa, được biểu diễn bằng hertz (Hz).

hop_length (`int`, *optional*, mặc định là 160) : Độ dài của các cửa sổ chồng lấp cho STFT được sử dụng để lấy các hệ số Mel Frequency.

n_fft (`int`, *tuỳ chọn*, mặc định là 512) : Kích thước của phép biến đổi Fourier.

win_length (`int`, *tuỳ chọn*, mặc định là 400) : Độ dài cửa sổ cho phép tính STFT.

preemphasis (`float`, *optional*, mặc định là 0.97) : Hệ số của bộ lọc tiền nhấn mạnh. 0.0 có nghĩa là không có bộ lọc tiền nhấn mạnh.

padding_value (`float`, *optional*, mặc định là 0.0) : Giá trị đệm được sử dụng để đệm âm thanh. Nên tương ứng với các khoảng im lặng.

mel_filters_dtype (`str`, *tuỳ chọn*, mặc định là `"float32"`) : Độ chính xác của bộ lọc mel và cửa sổ STFT được lưu trữ. Một số checkpoint giữ các hằng số này ở độ chính xác giảm (`"bfloat16"` đối với Nemotron 3.5 Transcribe): khi đó, bộ lọc và cửa sổ sẽ được làm tròn về dtype đó khi tính toán các đặc trưng, để các đặc trưng log-mel khớp với front-end gốc; bản thân spectrogram luôn được tính toán ở float32.

Tạo một bộ trích xuất đặc tính NemotronAsrStreaming.

Feature extractor này kế thừa từ [SequenceFeatureExtractor](/docs/transformers/v5.23.0/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), bao gồm hầu hết các phương thức chính. Người dùng nên tham khảo lớp cha này để biết thêm thông tin về các phương thức đó.

Lớp này trích xuất các đặc trưng mel-filter bank từ giọng nói thô bằng cách sử dụng một cài đặt numpy tùy chỉnh của `Short Time Fourier Transform`, vốn nên khớp với tương đương `torch.stft` của pytorch.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L34)

**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.

supported_num_lookahead_tokens (`list[int]`, *optional*) : Các ngữ cảnh chú ý bên phải (lookaheads, trong các khung encoder được lấy mẫu con) mà mô hình được huấn luyện với. Bộ xử lý là nguồn sự thật duy nhất cho tập hợp này: `set_num_lookahead_tokens()` sẽ kiểm tra đối chiếu với nó. Mặc định là tập hợp nhận thức bộ đệm NeMo `[13, 6, 1, 0]`.

default_num_lookahead_tokens (`int`, *tuỳ chọn*) : Ngữ cảnh bên phải được dùng để xác định kích thước các khối streaming và được phát ra bởi [__call__()](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__); thay đổi nó bằng `set_num_lookahead_tokens()`. Mặc định là mục đầu tiên của `supported_num_lookahead_tokens`.

Tạo một NemotronAsrStreamingProcessor, đó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.

[NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) 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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L83)

**Tham số:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh.

text (`Union[str, list[str], list[list[str]]]`, *tùy chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu bạn truyền vào đầu vào đã tách token trước, hãy đặt `is_split_into_words=True` để tránh nhầm lẫn với các đầu vào dạng lô.

sampling_rate (`int`, *optional*) : Tần số lấy mẫu của âm thanh đầu vào, tính bằng Hz. Giá trị này phải khớp với tần số lấy mẫu mà bộ trích xuất đặc trưng kỳ vọng (mặc định là 16000 Hz). Nếu được cung cấp, nó sẽ được kiểm tra đối chiếu với tần số lấy mẫu kỳ vọng của bộ xử lý, và một lỗi sẽ được phát sinh nếu chúng không khớp. Nếu không được cung cấp, một cảnh báo sẽ được phát ra và tần số lấy mẫu mặc định sẽ được giả định.

is_streaming (`bool`, *tuỳ chọn*, mặc định là `False`) : Có xử lý âm thanh ở chế độ streaming hay không. Khi `True`, âm thanh có thể được truyền theo từng phần, sử dụng `is_first_audio_chunk` để phân biệt phần đầu tiên với các phần tiếp theo.

is_first_audio_chunk (`bool`, *tuỳ chọn*, mặc định là `True`) : Xác định xem âm thanh hiện tại có phải là khối đầu tiên của một phiên streaming hay không. Bộ trích xuất đặc trưng sử dụng `center=True` cho khối đầu tiên (và cho việc sử dụng offline) và `center=False` cho các khối tiếp theo, để STFT theo từng khối tái tạo lại, theo từng khung, một lượt xử lý toàn bộ câu nói. Phải là `True` khi `is_streaming=False`.

return_mm_token_type_ids (`bool`, *kwargs*) : Có nên trả về các id loại token đa phương thức chỉ định vị trí của các token placeholder đa phương thức hay không.

return_text_replacement_offsets (`bool`, *kwargs*) : Có nên trả về các vị trí ký tự cho mỗi placeholder đa phương thức và phần thay thế của nó hay không.

return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

**Trả về:** [BatchFeature](/docs/transformers/v5.23.0/vi/main_classes/feature_extractor#transformers.BatchFeature)

đầu ra của feature-extractor (và tokenizer tùy chọn), được bổ sung thêm:

- **num_lookahead_tokens** -- Ngữ cảnh chú ý phía bên phải (lookahead, trong các khung encoder được lấy mẫu con), tức là `default_num_lookahead_tokens` (được đặt thông qua `set_num_lookahead_tokens()`). Truyền nó vào forward của model/encoder (hoặc `generate`); nó đóng vai trò của `num_delay_tokens` trong Voxtral Realtime.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L166)

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.

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

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

```python
transformers.NemotronAsrStreamingEncoderModelOutput(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, 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L325)

**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).

attention_mask (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Mask để tránh thực hiện attention trên các chỉ số token padding sau khi nén chuỗi. Được trả về vì độ dài chuỗi có thể khác với độ dài chuỗi đầu vào. Các giá trị mask được chọn trong `[0, 1]`:  - 1 cho các token **không bị mask**, - 0 cho các token **bị mask**.

past_key_values (`Cache`, *tuỳ chọn*) : Bộ nhớ đệm K/V trượt cửa sổ của cơ chế chú ý đã được cập nhật từ bộ mã hóa. Truyền vào cuộc gọi chunk tiếp theo.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *tùy chọn*) : Bộ đệm streaming thống nhất hỗ trợ các lớp Conv2d subsampling và Conv1d depthwise của conformer.

Mở rộng `ParakeetEncoderModelOutput` với các bộ nhớ đệm (cache) tùy chọn cho chế độ phát trực tiếp (streaming). Các bộ nhớ đệm chỉ được điền dữ liệu cho các mô hình nhận thức bộ nhớ đệm khi `use_cache=True`.

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

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

```python
transformers.NemotronAsrStreamingRNNTOutput(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.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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_past_key_values (`Cache`, *tuỳ chọn*): Bộ nhớ đệm K/V trượt cửa sổ cho chú ý của bộ mã hóa đã được cập nhật, được trả về khi mã hóa âm thanh với `use_cache=True` (truyền trực tiếp có nhận thức bộ nhớ đệm). Truyền nó vào bước forward của khối tiếp theo. padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *tuỳ chọn*): Bộ nhớ đệm conv truyền trực tiếp thống nhất đã được cập nhật (Conv2d hạ mẫu + Conv1d chiều sâu 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.

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L877)

**Tham số:**

config ([NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : 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.

Mô hình Encoder NemotronAsrStreaming, dựa trên kiến trúc [Fast Conformer](https://huggingface.co/papers/2305.05084).

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L900)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`) : 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)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

past_key_values (`Cache`, *optional*) : Bộ nhớ đệm K/V dạng cửa sổ trượt (`DynamicCache` được xây dựng từ `config.sliding_window`) cho chú ý streaming nhận thức bộ nhớ đệm.

output_attention_mask (`bool`, *tùy chọn*, mặc định là `True`) : Có trả về output attention mask hay không. Chỉ có hiệu lực khi `attention_mask` được cung cấp.

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *tùy chọn*) : Bộ đệm streaming thống nhất hỗ trợ các lớp Conv2d subsampling và Conv1d depthwise của conformer.

num_lookahead_tokens (`int`, *optional*) : Ghi đè ngữ cảnh chú ý bên phải (nhìn trước, trong các khung encoder được lấy mẫu con) cho bước truyền tiến này. Kết hợp với ngữ cảnh bên trái `config.sliding_window - 1`. Mặc định là `config.default_num_lookahead_tokens`.

**Trả về:** [BaseModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 [NemotronAsrStreamingEncoder](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoder) 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.
- **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.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**Tham số:**

config ([NemotronAsrStreamingConfig](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig)) : 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.

NemotronAsrStreaming Encoder với đầu RNN-T (Recurrent Neural Network Transducer).

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**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 (`NemotronAsrStreamingRNNTDecoderCache`, *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 (`NemotronAsrStreamingEncoderModelOutput`, *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`.

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

Một [NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) 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 [NemotronAsrStreamingForRNNT](/docs/transformers/v5.23.0/vi/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingForRNNT) 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.

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

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

