Transformers documentation

Nemotron 3.5 ASR

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

이 모델은 2026-06-27에 Hugging Face Transformers에 기여되었습니다.

Nemotron 3.5 ASR

개요

Nemotron 3.5 ASR는 NVIDIA에서 개발한 600M 파라미터의 다국어 음성 인식 모델로, 낮은 지연 시간의 스트리밍 환경과 높은 처리량의 배치 환경 모두에서 고품질 전사를 위해 설계되었습니다. 이 모델은 기본적으로 구두점과 대문자 표기를 지원합니다. 스트리밍 처리 시 80ms, 160ms, 560ms, 1120ms로 구성된 설정 가능한 청크 크기를 제공하여, 사용자는 애플리케이션의 요구 사항에 따라 지연 시간과 정확도 사이의 균형을 조절할 수 있습니다. 이 기능의 핵심은 캐시 인식 FastConformer-RNNT 아키텍처입니다. 오버랩되는 오디오 윈도우를 반복적으로 재처리하는 기존 버퍼링 기반 스트리밍 방식과 달리, 이 모델은 이전 청크에서 캐시된 인코더 컨텍스트를 재사용하면서 새로 들어오는 청크만 처리합니다. 이를 통해 중복 계산을 제거하고 효율성을 크게 향상시키며, 정확도를 희생하지 않으면서도 끝에서 끝까지의 지연 시간을 최소화하여 실시간 전사 워크로드에 적합합니다.

사용

오프라인 전사

Pipeline

AutoModel

스트리밍 전사

이것은 실험적 기능이며 API는 변경될 수 있습니다.

실시간 전사를 위해 오디오는 다음 규칙에 따라 청크로 나뉩니다:

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

스트리밍 지연

레이턴시는 num_lookahead_tokens에 의해 결정됩니다. 이는 각 청크가 출력되기 전에 대기하는 오른쪽 어텐션 컨텍스트(서브샘플링된 인코더 프레임의 룩어헤드)입니다. 값이 클수록 각 청크가 더 많은 미래 오디오를 볼 수 있어 정확도는 높아지지만 레이턴시도 함께 증가합니다. 지원되는 트레이드오프를 확인하고 하나를 선택한 후, 그에 따른 레이턴시를 읽어 보십시오:

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는 프로세서가 출력하는 청크의 크기를 결정하며, 이에 대응하는 num_lookahead_tokens는 generate까지 전달되어야 합니다(위 스니펫에서는 **inputs/**first_chunk_inputs를 통해 num_lookahead_tokens가 전달됩니다). 스트리밍 generate에서는 이 값이 누락되면 예외가 발생합니다.

Nemotron3_5AsrConfig

class transformers.Nemotron3_5AsrConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 13088decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 0blank_token_id: int = 13087num_prompts: int = 128prompt_intermediate_size: int = 2048default_prompt_id: int = 101 )

매개변수

is_encoder_decoder (bool, 선택 사항, 기본값 True) — 모델이 인코더/디코더로 사용되는지 여부를 나타냅니다.
vocab_size (int, 선택 사항, 기본값 13088) — 공백 토큰을 포함한 결합 네트워크 출력의 어휘 크기입니다.
decoder_hidden_size (int, 선택 사항, 기본값 640) — LSTM 예측 네트워크의 hidden size(NeMo의 pred_hidden).
num_decoder_layers (int, 선택 사항, 기본값 2) — 예측 네트워크의 LSTM 레이어 수.
hidden_act (str, 선택 사항, 기본값 "relu") — 합성 네트워크의 활성화 함수.
max_symbols_per_step (int, 선택 사항, 기본값 10) — 탐욕스러운 디코딩 과정에서 인코더 시간 단계마다 출력되는 비공백 심볼의 최대 개수.
encoder_config (Union[dict, NemotronAsrStreamingEncoderConfig], 선택) — 인코더의 config 객체 또는 사전입니다. 인코더가 NemotronAsrStreaming의 것과 동일하므로 NemotronAsrStreamingEncoderConfig를 그대로 재사용합니다.
pad_token_id (int, 선택 사항, 기본값 0) — 어휘에서 패딩에 사용되는 토큰 ID입니다.
blank_token_id (int, 선택 사항, 기본값 13087) — RNN-T 디코딩에 사용되는 blank token id입니다.
num_prompts (int, 선택 사항, 기본값 128) — 언어 프롬프트 슬롯의 수입니다. 대상 언어는 이 크기의 one-hot 벡터로 인코딩되며, 인코더 시간 축에 걸쳐 broadcast된 후 prompt_kernel fusion MLP를 통과하기 전에 인코더 출력과 연결됩니다.
prompt_intermediate_size (int, 선택 사항, 기본값 2048) — prompt_kernel fusion MLP의 hidden size(Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)).
default_prompt_id (int, 선택 사항, 기본값 101) — prompt_ids가 제공되지 않을 때 모델을 조건화하는 데 사용되는 프롬프트 인덱스입니다. 기본값은 auto 언어 감지 슬롯(NeMo 프롬프트 사전의 인덱스 101)으로, NeMo의 기본값인 target_lang="auto"와 일치합니다. 모델이 언어를 스스로 감지하고 <xx-XX> 태그를 출력합니다.

이것은 Nemotron3_5AsrForRNNT의 설정을 저장하기 위한 설정 클래스입니다. 지정된 인자에 따라 Nemotron3 5 Asr 모델을 초기화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 설정을 초기화하면 nvidia/nemotron-3.5-asr-streaming-0.6b와 유사한 설정이 생성됩니다.

Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.

예:

>>> from transformers import Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

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

Nemotron3_5AsrProcessor

클래스 transformers.Nemotron3_5AsrProcessor

< source >

( feature_extractortokenizerblank_token = '<blank>'decoder_type = Nonesupported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = Noneprompt_dictionary = Nonenum_prompts = 128 )

매개변수

feature_extractor (NemotronAsrStreamingFeatureExtractor) — 피처 추출기는 필수 입력입니다.
tokenizer (ParakeetTokenizer) — 토크나이저는 필수 입력값입니다.
blank_token (str, 선택 사항, 기본값 "<blank>") — RNN-T 디코딩에 사용되는 빈 토큰입니다.
decoder_type (str, 선택 사항) — 디코딩/타임스탬프 출력 모드(예: "ctc", "rnnt", "tdt"). None인 경우 하위 호환성을 위해 디코더 유형이 자동으로 추론됩니다.
supported_num_lookahead_tokens (list[int], 선택 사항) — NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens를 반영하여, 서브샘플링된 인코더 프레임의 오른쪽 어텐션 컨텍스트(lookahead)를 지원합니다. streaming_latency_ms를 검증하고 반환되는 num_lookahead_tokens를 유도하는 데 사용됩니다.
default_num_lookahead_tokens (int, 선택 사항) — streaming_latency_ms가 제공되지 않을 때 사용되는 오른쪽 컨텍스트입니다. 기본값은 supported_num_lookahead_tokens의 첫 번째 항목입니다.
prompt_dictionary (dict[str, int], 선택) — 대상 언어 문자열(예: "en-US", "de-DE", 코드만인 "de", 또는 "auto")에서 해당 프롬프트 인덱스로의 매핑입니다. 기본값은 NeMo 체크포인트의 프롬프트 사전입니다.
num_prompts (int, 선택 사항, 기본값 128) — 언어 프롬프트 슬롯의 수(원-핫 프롬프트 벡터의 크기)로, Nemotron3_5AsrConfig.num_prompts와 동일합니다.

Nemotron3_5AsrProcessor를 생성하며, feature extractor와 tokenizer를 단일 processor로 래핑합니다.

Nemotron3_5AsrProcessor는 NemotronAsrStreamingFeatureExtractor와 ParakeetTokenizer의 모든 기능을 제공합니다. 자세한 내용은 ~NemotronAsrStreamingFeatureExtractor와 ~ParakeetTokenizer를 참고하세요.

decode

< source >

( *argsdurations = None**kwargs )

decode()로 인수를 전달하고, durations가 제공된 경우 NeMo 라이브러리에서와 마찬가지로 토큰 수준의 타임스탬프를 후처리합니다.

set_num_lookahead_tokens

< source >

( num_lookahead_tokens: int )

스트리밍에 사용되는 올바른 attention context(하위 샘플링된 encoder 프레임 내의 lookahead)를 선택합니다.

default_num_lookahead_tokens를 설정하여, 모든 파생 스트리밍 속성(num_mel_frames_first_audio_chunk, num_mel_frames_per_audio_chunk, num_samples_first_audio_chunk, num_samples_per_audio_chunk)가 새로운 값으로부터 다시 파생되도록 합니다. num_lookahead_tokens는 supported_num_lookahead_tokens 중 하나여야 합니다.

model.generate에 동일한 num_lookahead_tokens를 전달하여, forward에서 사용되는 attention의 right context가 여기서 생성된 chunk size와 일치하도록 하세요. 그렇지 않으면 스트리밍 generate가 예외를 발생시킵니다.

Nemotron3_5AsrRNNTOutput

class transformers.Nemotron3_5AsrRNNTOutput

< source >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneloss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedecoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

매개변수

last_hidden_state (torch.Tensor, shape (batch_size, sequence_length, hidden_size)) — 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
pooler_output (torch.Tensor, shape (batch_size, hidden_size)) — 보조 사전 학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 후의 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전 학습 단계에서 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
hidden_states (tuple(torch.Tensor), 선택 사항, 다음 조건에서 반환됩니다: output_hidden_states=True 이 전달되거나 config.output_hidden_states=True) — 다음 형태의 튜플: torch.Tensor (임베딩이 있는 경우 임베딩 레이어의 출력 1개 + 각 레이어의 출력 1개 (batch_size, sequence_length, hidden_size).
각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, 다음 조건에서 반환됩니다: output_attentions=True 이 전달되거나 config.output_attentions=True) — 다음의 튜플입니다: torch.Tensor (각 레이어마다 하나씩, 모양이 (batch_size, num_heads, sequence_length, sequence_length).
self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.
loss (torch.Tensor, 선택 사항, labels이 제공될 때 반환됨) — RNN-T transducer loss입니다.
logits (torch.Tensor, shape (batch_size, encoder_length, decoder_length, vocab_size + 1)) — 모든 인코더/디코더 프레임 쌍에 대해, 빈칸(blank) 심볼을 포함한 어휘 전체에 대한 joint-network 점수입니다.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, 선택) — 업데이트된 decoder LSTM 캐시입니다. 빈(blank) 예측 시 LSTM 단계를 건너뛰기 위해 재사용됩니다.
encoder_past_key_values (Cache, 선택 사항) — use_cache=True로 오디오를 인코딩할 때 반환되는 업데이트된 인코더 어텐션 K/V 슬라이딩 윈도우 캐시(캐시 인식 스트리밍). 다음 청크의 forward에 전달하세요.
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, 선택 사항) — use_cache=True로 오디오를 인코딩할 때 반환되는 통합 스트리밍 컨볼루션 캐시(서브샘플링 Conv2d + conformer depthwise Conv1d)입니다. 다음 청크의 forward에 전달하세요.

Nemotron3_5AsrForRNNT

class transformers.Nemotron3_5AsrForRNNT

< source >

( config: Nemotron3_5AsrConfig )

매개변수

config (Nemotron3_5AsrConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 연관된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

RNN-T(Recurrent Neural Network Transducer) 헤드와 언어 ID 프롬프트 조건화를 갖춘 Nemotron3_5Asr 인코더

이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< source >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.modeling_outputs.BaseModelOutputWithPooling | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = Noneprompt_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5AsrRNNTOutput or tuple(torch.Tensor)

매개변수

input_features (torch.Tensor, shape (batch_size, sequence_length, feature_dim), 선택 사항) — 입력 오디오 특징에 해당하는 텐서입니다. 오디오 특징은 feature_extractor_class를 사용하여 얻을 수 있습니다. 자세한 내용은 feature_extractor_class.__call__를 참조하세요 (processor_class는 오디오 처리에 feature_extractor_class를 사용합니다).
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
decoder_input_ids (torch.LongTensor, shape (batch_size, 1), 선택 사항) — 단일 단계 추론을 위한 디코더 입력 토큰 ID입니다.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, 선택) — Decoder LSTM 캐시입니다. 빈(blank) 예측 시 LSTM 단계를 건너뛰기 위해 재사용됩니다.
use_decoder_cache (bool, 선택 사항) — 제공된 decoder cache가 없을 때 할당하여 사용할지 여부.
encoder_outputs (tuple(torch.Tensor), 선택 사항) — 미리 계산된 인코더 출력(last_hidden_state, pooler_output, …).
labels (torch.Tensor, shape (batch_size, sequence_length), 선택 사항) — 마스크 언어 모델링 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 [0, ..., config.vocab_size] 범위 내의 값이거나 -100이어야 합니다(input_ids docstring 참조). 인덱스가 -100으로 설정된 토큰은 무시(마스크)되며, 손실은 [0, ..., config.vocab_size] 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.
num_lookahead_tokens (int, 선택 사항) — 인코더로 전달되는 오른쪽 어텐션 컨텍스트(서브샘플링된 인코더 프레임 기준 lookahead). 기본값은 config.encoder_config.default_num_lookahead_tokens입니다.
prompt_ids (torch.LongTensor, shape (batch_size,), 선택 사항) — 언어 ID 조건화에 사용되는 언어 프롬프트 인덱스입니다. language로부터 프로세서가 생성하며, prompt_projector가 소비하는 브로드캐스트 원-핫 벡터로 변환됩니다.

반환값

Nemotron3_5AsrRNNTOutput 또는 tuple(torch.Tensor)

None 및 입력에 따라 다양한 요소를 포함하는 Nemotron3_5AsrRNNTOutput 또는 torch.Tensor의 튜플(return_dict=False가 전달되었거나 config.return_dict=False인 경우).

Nemotron3_5AsrForRNNT의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 forward pass의 레시피를 정의해야 하지만, 이후에는 이 함수 대신 Module 인스턴스를 호출해야 합니다. 전자는 전처리 및 후처리 단계를 실행하는 것을 처리하는 반면, 후자는 이를 조용히 무시하기 때문입니다.

last_hidden_state (torch.Tensor, shape (batch_size, sequence_length, hidden_size)) — 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
pooler_output (torch.Tensor, shape (batch_size, hidden_size)) — 보조 사전 학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 후의 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전 학습 동안 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
hidden_states (tuple(torch.Tensor), 선택 사항, output_hidden_states=True가 전달되거나 config.output_hidden_states=True인 경우 반환됨) — torch.Tensor의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 모양은 (batch_size, sequence_length, hidden_size)입니다.

각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
attentions (tuple(torch.Tensor), 선택 사항, output_attentions=True가 전달되었거나 config.output_attentions=True인 경우 반환됨) — 각 레이어마다 하나씩 포함된 torch.Tensor의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.
loss (torch.Tensor, 선택 사항, labels이 제공될 때 반환됨) — RNN-T transducer loss.
logits (torch.Tensor, shape (batch_size, encoder_length, decoder_length, vocab_size + 1)) — 모든 인코더/디코더 프레임 쌍에 대해, 빈칸(blank) 심볼을 포함한 어휘 전체에 대한 Joint-network 점수입니다.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, 선택 사항) — 업데이트된 decoder LSTM 캐시입니다. 빈(blank) 예측 시 LSTM 단계를 건너뛰기 위해 재사용됩니다.
encoder_past_key_values (Cache, 선택) — use_cache=True로 오디오를 인코딩할 때 반환되는 업데이트된 인코더 어텐션 K/V 슬라이딩 윈도우 캐시(캐시 인식 스트리밍). 다음 청크의 forward에 전달하세요.
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, 선택) — use_cache=True로 오디오를 인코딩할 때 반환되는 업데이트된 통합 스트리밍 컨볼루션 캐시(서브샘플링 Conv2d + conformer depthwise Conv1d). 다음 청크의 forward에 전달하세요.

예:

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

< source >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3 화자 분리 Nemotron 3.5 Transcribe→