Transformers documentation

Nemotron 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

이 모델은 2023-05-08에 HF papers에 게시되었으며, 2026-06-18에 Hugging Face Transformers에 기여되었습니다.

Nemotron ASR 스트리밍

개요

Nemotron ASR Streaming은 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-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()

스트리밍 지연

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

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

NemotronAsrStreamingConfig

class transformers.NemotronAsrStreamingConfig

< source >

매개변수

is_encoder_decoder (bool, 선택 사항, 기본값 True) — 모델이 인코더/디코더로 사용되는지 여부를 나타냅니다.
vocab_size (int, 선택 사항, 기본값 1025) — 모델의 어휘 크기입니다. input_ids로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.
decoder_hidden_size (int, 선택 사항, 기본값 640) — LSTM 예측 네트워크의 hidden size(NeMo의 pred_hidden)입니다. joint network는 encoder와 decoder의 출력을 모두 이 size로 투영합니다(NeMo의 joint_hidden이며, 알려진 모든 checkpoint는 이를 pred_hidden과 동일하게 설정합니다).
num_decoder_layers (int, 선택 사항, 기본값 2) — 예측 네트워크의 LSTM 레이어 수.
hidden_act (str, 선택 사항, 기본값 "relu") — 합성 네트워크의 활성화 함수.
max_symbols_per_step (int, 선택 사항, 기본값 10) — 탐욕스러운 디코딩 과정에서 인코더 시간 단계마다 출력되는 비공백 심볼의 최대 개수.
encoder_config (Union[dict, NemotronAsrStreamingEncoderConfig], 선택) — 인코더의 config 객체 또는 사전입니다.
pad_token_id (int, 선택 사항, 기본값 0) — 어휘에서 패딩에 사용되는 토큰 ID입니다.
blank_token_id (int, 선택 사항, 기본값 1024) — Blank token id입니다. RNN-T의 경우 pad_token_id와 다릅니다.

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

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

예:

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

class transformers.NemotronAsrStreamingEncoderConfig

< 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02sliding_window: int = 71default_num_lookahead_tokens: int = 13 )

매개변수

hidden_size (int, 선택 사항, 기본값 1024) — 숨겨진 표현의 차원입니다.
num_hidden_layers (int, 선택 사항, 기본값 24) — Transformer decoder의 숨겨진 레이어 수.
num_attention_heads (int, 선택 사항, 기본값 8) — Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.
intermediate_size (int, 선택 사항, 기본값 4096) — MLP 표현의 차원입니다.
hidden_act (str, 선택 사항, 기본값 silu) — 디코더의 비선형 활성화 함수(함수 또는 문자열)입니다. 예를 들어, "gelu", "relu", "silu" 등이 있습니다.
attention_bias (bool, 선택 사항, 기본값 True) — 자기 주의(self-attention) 시 query, key, value 및 출력 투영 계층에 bias를 사용할지 여부입니다.
convolution_bias (bool, 선택 사항, 기본값 True) — conformer의 convolution module에서 convolution에 bias를 사용할지 여부입니다.
conv_kernel_size (int, 선택 사항, 기본값 9) — Conformer 블록의 컨볼루션 레이어의 커널 크기입니다.
subsampling_factor (int, 선택 사항, 기본값 8) — 입력 시퀀스를 서브샘플링하는 배율입니다.
subsampling_conv_channels (int, 선택 사항, 기본값 256) — 하위 샘플링 컨볼루션 레이어의 채널 수입니다.
num_mel_bins (int, 선택 사항, 기본값 80) — mel 특징의 개수.
subsampling_conv_kernel_size (int, 선택 사항, 기본값 3) — 하위 샘플링 컨볼루션 레이어의 커널 크기입니다.
subsampling_conv_stride (int, 선택 사항, 기본값 2) — 하위 샘플링 컨볼루션 레이어의 스트라이드입니다.
dropout (Union[float, int], 선택 사항, 기본값 0.1) — 모든 dropout 레이어에 적용할 비율입니다.
dropout_positions (float, 선택 사항, 기본값 0.0) — 입력 시퀀스의 위치(positions)에 적용할 dropout 비율입니다.
layerdrop (Union[float, int], 선택 사항, 기본값 0.1) — LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](https://huggingface.co/papers/1909.11556 참조)을 참고하세요.
activation_dropout (Union[float, int], 선택 사항, 기본값 0.1) — 완전 연결 레이어 내부 활성화에 적용할 dropout 비율입니다.
attention_dropout (Union[float, int], 선택 사항, 기본값 0.1) — Attention 확률에 적용할 dropout 비율입니다.
max_position_embeddings (int, 선택 사항, 기본값 5000) — 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.
scale_input (bool, 선택 사항, 기본값 True) — 입력 임베딩을 스케일링할지 여부입니다.
initializer_range (float, 선택 사항, 기본값 0.02) — 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.
sliding_window (int, 선택 사항, 기본값 71) — K/V attention 슬라이딩 윈도우 크기(하위 샘플링된 인코더 프레임 단위)입니다. 이는 left_context + 1(현재 프레임과 왼쪽 컨텍스트)과 같으므로, 왼쪽 attention 컨텍스트는 sliding_window - 1입니다. 모든 지원되는 lookahead에서 동일합니다.
default_num_lookahead_tokens (int, 선택 사항, 기본값 13) — forward에 컨텍스트가 전달되지 않을 때 사용되는 오른쪽 어텐션 컨텍스트(서브샘플링된 인코더 프레임 기준 lookahead)입니다. 모델 학습 시 지원된 값의 집합은 NemotronAsrStreamingProcessor에 정의되어 있습니다.

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

예:

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

class transformers.NemotronAsrStreamingFeatureExtractor

< source >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0mel_filters_dtype = 'float32'**kwargs )

매개변수

feature_size (int, 선택 사항, 기본값 80) — 추출된 특징의 차원입니다.
sampling_rate (int, 선택 사항, 기본값 16000) — 오디오 파일을 디지털화할 때 사용할 샘플링 주파수(Hz).
hop_length (int, 선택 사항, 기본값 160) — Mel Frequency 계수를 얻기 위해 사용되는 STFT의 겹치는 윈도우 길이.
n_fft (int, 선택 사항, 기본값 512) — 푸리에 변환의 크기.
win_length (int, 선택 사항, 기본값 400) — STFT 계산에 사용되는 윈도우 길이입니다.
preemphasis (float, 선택 사항, 기본값 0.97) — 프리임페이스 필터 계수입니다. 0.0은 프리임페이스 필터를 사용하지 않음을 의미합니다.
padding_value (float, 선택 사항, 기본값 0.0) — 오디오를 패딩하는 데 사용되는 값입니다. 무음 구간과 대응해야 합니다.
mel_filters_dtype (str, 선택 사항, 기본값 "float32") — 저장된 mel filter bank와 STFT window의 정밀도입니다. 일부 checkpoint는 이러한 상수를 축소된 정밀도("bfloat16", Nemotron 3.5 Transcribe의 경우)로 유지합니다. 이 경우 feature 계산 시 filter bank와 window가 해당 dtype으로 반올림되어, log-mel feature가 원래의 front-end와 일치합니다. spectrogram 자체는 항상 float32로 계산됩니다.

NemotronAsrStreaming feature extractor를 생성합니다.

이 feature extractor는 SequenceFeatureExtractor를 상속하며, 이 클래스에는 대부분의 주요 메서드가 포함되어 있습니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.

이 클래스는 Short Time Fourier Transform의 커스텀 numpy 구현을 사용하여 원시 음성에서 mel-filter bank 특징을 추출하며, pytorch의 torch.stft와 동일한 결과를 내야 합니다.

NemotronAsrStreamingProcessor

class transformers.NemotronAsrStreamingProcessor

< source >

( feature_extractortokenizerblank_token = '<blank>'supported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = None )

매개변수

feature_extractor (NemotronAsrStreamingFeatureExtractor) — 피처 추출기는 필수 입력입니다.
tokenizer (ParakeetTokenizer) — 토크나이저는 필수 입력값입니다.
blank_token (str, 선택 사항, 기본값 "<blank>") — RNN-T 디코딩에 사용되는 빈 토큰입니다.
supported_num_lookahead_tokens (list[int], 선택 사항) — 모델이 학습될 때 사용된 오른쪽 attention 컨텍스트(서브샘플링된 인코더 프레임의 lookahead)입니다. 이 집합에 대한 단일 진실 공급원(single source of truth)은 프로세서이며, set_num_lookahead_tokens()는 이를 기준으로 검증합니다. 기본값은 NeMo cache-aware 집합 [13, 6, 1, 0]입니다.
default_num_lookahead_tokens (int, 선택 사항) — call()에서 스트리밍 청크 크기를 결정하고 출력하는 데 사용되는 오른쪽 컨텍스트입니다. set_num_lookahead_tokens()로 변경할 수 있습니다. 기본값은 supported_num_lookahead_tokens의 첫 번째 항목입니다.

feature extractor와 tokenizer를 단일 processor로 감싸는 NemotronAsrStreamingProcessor를 생성합니다.

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

call

< source >

( 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 = Nonesampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool | None = True**kwargs: *<class 'transformers.models.nemotron_asr_streaming.processing_nemotron_asr_streaming.NemotronAsrStreamingProcessorKwargs'> ) → BatchFeature

매개변수

audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]) — 준비할 오디오 또는 오디오 배치입니다. 각 오디오는 NumPy 배열 또는 PyTorch 텐서일 수 있습니다. NumPy 배열/PyTorch 텐서의 경우, 각 오디오의 shape은 (C, T)여야 하며, 여기서 C는 채널 수, T는 오디오의 샘플 길이입니다.
text (Union[str, list[str], list[list[str]]], 선택 사항) — 인코딩할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 문자열 또는 문자열 목록(사전 토큰화된 문자열)일 수 있습니다. 사전 토큰화된 입력을 전달하는 경우, 배치 입력과의 혼동을 피하기 위해 is_split_into_words=True를 설정하세요.
sampling_rate (int, 선택 사항) — 입력 오디오의 Hz 단위 샘플링 레이트입니다. 이는 feature extractor가 기대하는 샘플링 레이트와 일치해야 합니다(기본값은 16000 Hz). 값이 제공되면 processor가 기대하는 샘플링 레이트와 검증되며, 일치하지 않으면 오류가 발생합니다. 제공되지 않으면 경고가 표시되고 기본 샘플링 레이트가 가정됩니다.
is_streaming (bool, 선택 사항, 기본값 False) — 스트리밍 모드로 오디오를 처리할지 여부입니다. True인 경우, 오디오를 청크 단위로 전달할 수 있으며 is_first_audio_chunk를 사용하여 첫 번째 청크와 이후의 청크를 구별합니다.
is_first_audio_chunk (bool, 선택 사항, 기본값 True) — 현재 오디오가 스트리밍 세션의 첫 번째 청크인지 여부입니다. feature extractor는 첫 번째 청크(및 오프라인 사용 시)에 center=True를, 이후 청크에는 center=False를 사용하여, 청크별 STFT가 프레임 단위로 단일 전체 발화 패스를 재현하도록 합니다. is_streaming=False인 경우 True여야 합니다.
return_tensors (str 또는 TensorType, 선택 사항) — 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:
- 'pt': PyTorch torch.Tensor 객체를 반환합니다.
- 'np': NumPy np.ndarray 객체를 반환합니다.
**kwargs (ProcessingKwargs, 선택) — 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

반환값

BatchFeature

다음 항목이 추가된 feature-extractor(및 선택적 tokenizer) 출력:

num_lookahead_tokens — 오른쪽 attention 컨텍스트(서브샘플링된 인코더 프레임에서의 lookahead)입니다. 즉, default_num_lookahead_tokens(set_num_lookahead_tokens()을 통해 설정)입니다. 모델/인코더 forward(또는 generate)에 전달하며, Voxtral Realtime의 num_delay_tokens 역할을 수행합니다.

decode

< source >

( *argsdurations = None**kwargs )

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

NemotronAsrStreamingEncoderModelOutput

class transformers.NemotronAsrStreamingEncoderModelOutput

< 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 = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.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 가중치.
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 시퀀스 압축 후 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 하는 마스크입니다. 시퀀스 길이가 입력 시퀀스 길이와 다를 수 있으므로 반환됩니다. 선택된 마스크 값은 [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
past_key_values (Cache, 선택 사항) — 인코더에서 업데이트된 어텐션 K/V 슬라이딩 윈도우 캐시입니다. 다음 청크 호출에 전달하세요.
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, 선택 사항) — 서브샘플링 Conv2d 레이어와 conformer depthwise Conv1d를 뒷받침하는 통합 스트리밍 캐시입니다.

ParakeetEncoderModelOutput를 확장하며, 선택적 스트리밍 캐시를 포함합니다. 캐시는 use_cache=True일 때 캐시 인식 모델에 대해서만 값이 채워집니다.

NemotronAsrStreamingRNNTOutput

class transformers.NemotronAsrStreamingRNNTOutput

< 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.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

encoder_past_key_values (Cache, 선택 사항): use_cache=True로 오디오를 인코딩할 때 반환되는 업데이트된 인코더 어텐션 K/V 슬라이딩 윈도우 캐시입니다(캐시 인식 스트리밍). 다음 청크의 forward에 전달하세요. padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, 선택 사항): use_cache=True로 오디오를 인코딩할 때 반환되는 업데이트된 통합 스트리밍 컨볼루션 캐시(서브샘플링 Conv2d + conformer depthwise Conv1d)입니다. 다음 청크의 forward에 전달하세요.

NemotronAsrStreamingEncoder

class transformers.NemotronAsrStreamingEncoder

< source >

( config: NemotronAsrStreamingEncoderConfig )

매개변수

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

Fast Conformer 아키텍처를 기반으로 한 NemotronAsrStreaming Encoder 모델입니다.

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

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

forward

< source >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneoutput_attention_mask: bool = Trueuse_cache: bool | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput 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
어텐션 마스크란 무엇인가요?
position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 위치 임베딩에서 각 입력 시퀀스 토큰의 위치 인덱스. 범위 [0, config.n_positions - 1].
포지션 ID란 무엇인가요?
past_key_values (Cache, 선택 사항) — 캐시 인식 스트리밍 어텐션을 위한 슬라이딩 윈도우 K/V 캐시(config.sliding_window로 생성된 DynamicCache)
output_attention_mask (bool, 선택 사항, 기본값 True) — 출력 attention mask를 반환할지 여부입니다. attention_mask가 제공된 경우에만 적용됩니다.
use_cache (bool, 선택 사항) — True로 설정하면 past_key_values 키 값 상태가 반환되며, 디코딩 속도를 높이는 데 사용할 수 있습니다( past_key_values 참조).
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, 선택 사항) — 서브샘플링 Conv2d 레이어와 conformer depthwise Conv1d를 뒷받침하는 통합 스트리밍 캐시입니다.
num_lookahead_tokens (int, 선택 사항) — 이 forward pass에 대한 오른쪽 attention 컨텍스트(서브샘플링된 인코더 프레임에서의 lookahead)를 재정의합니다. 왼쪽 컨텍스트 config.sliding_window - 1과 함께 사용됩니다. 기본값은 config.default_num_lookahead_tokens입니다.

반환값

BaseModelOutput 또는 tuple(torch.Tensor)

None 및 입력에 따라 다양한 요소로 구성된 BaseModelOutput 또는 torch.Tensor의 튜플(return_dict=False가 전달되었거나 config.return_dict=False인 경우).

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

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

last_hidden_state (torch.Tensor, shape (batch_size, sequence_length, hidden_size)) — 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
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 가중치.

예:

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

class transformers.NemotronAsrStreamingForRNNT

< source >

( config: NemotronAsrStreamingConfig )

매개변수

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

RNN-T(Recurrent Neural Network Transducer) 헤드를 갖춘 NemotronAsrStreaming Encoder입니다.

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.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → NemotronAsrStreamingRNNTOutput 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 (NemotronAsrStreamingRNNTDecoderCache, 선택) — Decoder LSTM 캐시입니다. 빈(blank) 예측 시 LSTM 단계를 건너뛰기 위해 재사용됩니다.
use_decoder_cache (bool, 선택 사항) — 제공된 decoder cache가 없을 때 할당하여 사용할지 여부.
encoder_outputs (NemotronAsrStreamingEncoderModelOutput, 선택) — 미리 계산된 인코더 출력(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입니다.

반환값

NemotronAsrStreamingRNNTOutput 또는 tuple(torch.Tensor)

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

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

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

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

< source >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3.5 Transcribe NeuCodec→