# Nemotron 3.5 ASR

## 개요

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

## 사용

### 오프라인 전사

```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]
> 파이프라인은 기본 언어 프롬프트(인덱스 0, `en-US`)를 사용합니다. 명시적인 언어 조건부 처리나 자동 감지가 필요하면 프로세서의 `language` 인수를 전달하세요(AutoModel 탭 참조).

언어 프롬프트는 프로세서에 의해 생성되므로, 언어는 입력과 함께 `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))
```

### 스트리밍 전사
> [!NOTE]
> 이것은 실험적 기능이며 API는 변경될 수 있습니다.

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

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

#### 스트리밍 지연

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

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

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

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

**매개변수:**

is_encoder_decoder (`bool`, *선택 사항*, 기본값 `True`) : 모델이 인코더/디코더로 사용되는지 여부.

vocab_size (`int`, *선택 사항*, 기본값 13088) : 결합 네트워크 출력의 어휘 크기(빈 토큰 포함).

decoder_hidden_size (`int`, *선택 사항*, 기본값 640) : LSTM 예측 네트워크의 숨겨진 크기(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](/docs/transformers/v5.23.0/ko/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)를 그대로 재사용합니다.

pad_token_id (`int`, *선택 사항*, 기본값 `0`) : 어휘에서 패딩에 사용되는 토큰 ID입니다.

blank_token_id (`int`, *선택 사항*, 기본값 13087) : RNN-T 디코딩을 위한 빈 토큰 ID입니다.

num_prompts (`int`, *선택 사항*, 기본값 128) : 언어 프롬프트 슬롯의 수입니다. 대상 언어는 이 크기의 원-핫 벡터로 인코딩되며, 인코더 시간 축에 걸쳐 브로드캐스트된 후 `prompt_kernel` 융합 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](https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

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

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

**매개변수:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : feature extractor는 필수 입력입니다.

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](/docs/transformers/v5.23.0/ko/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrProcessor)는 [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor)와 [ParakeetTokenizer](/docs/transformers/v5.23.0/ko/model_doc/parakeet#transformers.ParakeetTokenizer)의 모든 기능을 제공합니다. 자세한 내용은 [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/ko/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor)와 [~ParakeetTokenizer](/docs/transformers/v5.23.0/ko/model_doc/parakeet#transformers.ParakeetTokenizer)를 참고하세요.

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

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

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

[decode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode)로 인수를 전달하고, `durations`가 제공된 경우 NeMo 라이브러리에서와 마찬가지로 토큰 수준의 타임스탬프를 후처리합니다.

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

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

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

스트리밍에 사용되는 올바른 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 크기와 일치하도록 하세요. 그렇지 않으면 스트리밍 `generate`가 예외를 발생시킵니다.

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

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

**매개변수:**

last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) : 모델의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스.

pooler_output (`torch.Tensor`, shape `(batch_size, hidden_size)`) : 서보 학습(auxiliary pretraining) 작업에 사용되는 레이어들을 통해 추가 처리된 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 후의 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전 학습(pretraining) 단계에서 다음 문장 예측(분류) 목적함수를 통해 학습됩니다.

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`의 튜플(레이어당 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

loss (`torch.Tensor`, *선택 사항*, `labels`가 제공될 때 반환됨) : RNN-T transducer 손실.

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`, *선택*) : 통합 스트리밍 컨볼루션 캐시(서브샘플링 Conv2d + conformer depthwise Conv1d)를 업데이트하여 반환합니다. `use_cache=True`로 오디오를 인코딩할 때 반환되며, 다음 청크의 forward에 전달해야 합니다.

## Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

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

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

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

**매개변수:**

config ([Nemotron3_5AsrConfig](/docs/transformers/v5.23.0/ko/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

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

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

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

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

**매개변수:**

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`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, 1)`, *선택 사항*) : 단일 단계 추론을 위한 디코더 입력 토큰 ID입니다.

decoder_cache (`Nemotron3_5AsrRNNTDecoderCache`, *선택 사항*) : Decoder LSTM 캐시. 빈(blank) 예측 시 LSTM 단계를 건너뛰기 위해 재사용됩니다.

use_decoder_cache (`bool`, *선택 사항*) : 캐시가 제공되지 않은 경우 디코더 캐시를 할당하고 사용할지 여부.

encoder_outputs (`tuple(torch.Tensor)`, *선택 사항*) : 사전 계산된 인코더 출력(last_hidden_state, pooler_output, ...).

labels (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[0, ..., config.vocab_size]` 범위 내이거나 -100이어야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`으로 설정된 토큰은 무시(마스크)되며, loss는 `[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`가 소비하는 브로드캐스트 원-핫(one-hot)으로 변환됩니다.

**반환값:** [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/ko/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) 또는 `tuple(torch.Tensor)`

`None` 및 입력에 따라 구성이 달라지는 다양한 요소로 구성된 [Nemotron3_5AsrRNNTOutput](/docs/transformers/v5.23.0/ko/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrRNNTOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[Nemotron3_5AsrForRNNT](/docs/transformers/v5.23.0/ko/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrForRNNT)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(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 손실.
- **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에 전달하세요.

예:

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

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

