Transformers documentation

Parakeet

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

이 모델은 2025-09-25에 Hugging Face Transformers에 기여되었습니다.

Parakeet

개요

NVIDIA NeMo에서 도입한 Parakeet 모델은 Fast Conformer 인코더와 CTC(Connectionist Temporal Classification), RNNT(Recurrent Neural Network Transducer) 또는 TDT(Token and Duration Transducer) 디코더를 결합하여 자동 음성 인식(ASR)을 수행하는 모델입니다.

모델 아키텍처

Fast Conformer Encoder: mel-spectrogram 특징을 처리하고 서브샘플링을 통해 시퀀스 길이를 줄이는 선형 확장 가능한 Conformer 아키텍처입니다. 이는 FastSpeech2Conformer에 포함된 Conformer Encoder의 더 효율적인 버전입니다(인코더 구현 및 세부 사항은 ParakeetEncoder를 참조하세요).
ParakeetForCTC: Fast Conformer Encoder + CTC decoder
- CTC Decoder: 다음으로 구성된 단순하지만 효과적인 디코더입니다:
  - 1D convolution은 인코더의 숨겨진 크기(hidden size)를 어휘 크기(vocabulary size)로 투영합니다(최적의 NeMo 호환성을 위해).
  - 학습을 위한 CTC 손실 계산.
  - 추론을 위한 Greedy CTC 디코딩.
ParakeetForRNNT: Fast Conformer Encoder + RNN-T (RNN Transducer) decoder
- RNN-T Decoder: 표준 신경 트랜스듀서:
  - LSTM 예측 네트워크는 토큰 예측에 걸쳐 언어 컨텍스트를 유지합니다.
  - Joint network은 인코더와 디코더의 출력을 결합합니다.
  - 추론을 위한 Greedy transducer decoding: blank emission은 인코더 프레임을 한 단계 앞당기고, non-blank emission은 동일한 프레임에 머무릅니다.
ParakeetForTDT: Fast Conformer Encoder + TDT(Token Duration Transducer) decoder
- TDT Decoder: 토큰과 그 지속 시간을 동시에 예측하여 효율적인 디코딩을 가능하게 합니다:
  - LSTM 예측 네트워크는 토큰 예측에 걸쳐 언어 컨텍스트를 유지합니다.
  - Joint network은 인코더와 디코더의 출력을 결합합니다.
  - Duration head는 프레임 건너뛰기 횟수를 예측하여 빠른 추론을 가능하게 합니다.

원래 구현은 NVIDIA NeMo에서 찾을 수 있습니다. 모델 체크포인트는 NVIDIA 조직 아래에서 찾을 수 있습니다.

이 모델은 Nithin Rao Koluguri, Eustache Le Bihan, Eric Bezzam, Maksym Lypivskyi, Hainan Xu에 의해 기여되었습니다.

사용

ParakeetForCTC 사용

Pipeline

AutoModel

ParakeetForRNNT 사용

Pipeline

AutoModel

타임스탬핑

Parakeet RNN-T는 대소문자 구분이나 구두점 없이 전사(CTC와 유사)하며, 모델은 토큰 타임스탬핑도 수행할 수 있습니다.

from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-rnnt-0.6b", revision="refs/pr/4")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was thirty five degrees in barcelona but today the temperature will go down to minus twenty degrees'}

TDT(토큰별 지속 시간을 예측하는 방식)와 달리, 각 RNN-T 토큰은 단일 인코더 프레임에서 출력되므로 시작과 끝이 정확히 하나의 프레임에 해당합니다.

from datasets import Audio, load_dataset
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision, device_map="auto")

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))
speech_samples = [el['array'] for el in ds["audio"][:1]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
decoded_output, decoded_timestamps = processor.decode(
    output.sequences,
    durations=output.durations,
    skip_special_tokens=True,
)
print("Transcription:", decoded_output)
print("\nTimestamped tokens:", decoded_timestamps)

"""
Transcription: ['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']

Timestamped tokens: [[{'token': 'm', 'start': 0.4, 'end': 0.48}, {'token': 'is', 'start': 0.56, 'end': 0.64}, {'token': 'ter', 'start': 0.56, 'end': 0.64}, {'token': ' qu', 'start': 0.72, 'end': 0.8}, {'token': 'il', 'start': 0.96, 'end': 1.04}, {'token': 'ter', 'start': 1.12, 'end': 1.2}, {'token': ' is', 'start': 1.36, 'end': 1.44}, {'token': ' the', 'start': 1.52, 'end': 1.6}, {'token': ' ap', 'start': 1.68, 'end': 1.76}, {'token': 'o', 'start': 1.76, 'end': 1.84}, {'token': 'st', 'start': 1.84, 'end': 1.92}, {'token': 'le', 'start': 2.0, 'end': 2.08}, {'token': ' of', 'start': 2.16, 'end': 2.24}, {'token': ' the', 'start': 2.24, 'end': 2.32}, {'token': ' m', 'start': 2.4, 'end': 2.48}, {'token': 'id', 'start': 2.48, 'end': 2.56}, {'token': 'd', 'start': 2.56, 'end': 2.64}, {'token': 'le', 'start': 2.56, 'end': 2.64}, {'token': ' cl', 'start': 2.8, 'end': 2.88}, {'token': 'ass', 'start': 2.88, 'end': 2.96}, {'token': 'es', 'start': 3.12, 'end': 3.2}, {'token': ' and', 'start': 3.28, 'end': 3.36}, {'token': ' we', 'start': 3.44, 'end': 3.52}, {'token': ' are', 'start': 3.6, 'end': 3.68}, {'token': ' gl', 'start': 3.84, 'end': 3.92}, {'token': 'ad', 'start': 3.92, 'end': 4.0}, {'token': ' to', 'start': 4.08, 'end': 4.16}, {'token': ' we', 'start': 4.24, 'end': 4.32}, {'token': 'l', 'start': 4.32, 'end': 4.4}, {'token': 'c', 'start': 4.4, 'end': 4.48}, {'token': 'ome', 'start': 4.48, 'end': 4.56}, {'token': ' his', 'start': 4.72, 'end': 4.8}, {'token': ' go', 'start': 4.96, 'end': 5.04}, {'token': 's', 'start': 5.04, 'end': 5.12}, {'token': 'pe', 'start': 5.2, 'end': 5.28}, {'token': 'l', 'start': 5.36, 'end': 5.44}]]
"""

ParakeetForTDT 사용

Pipeline

AutoModel

타임스탬핑

모델을 빠르게 실행하기

Parakeet은 그래프 캡처(그래프 캡처)를 통한 전체 그래프 컴파일을 지원합니다(NVIDIA GPU의 경우 CUDA graphs, 기타 가속기의 경우 동등한 메커니즘)! 이 최적화는 전사하려는 최대 오디오 길이를 알고 있을 때 가장 효과적입니다. 핵심 아이디어는 재컴파일을 피하기 위해 정적 입력 형태를 사용하는 것입니다. 예를 들어, 오디오가 30초 미만일 것이라고 알면, 프로세서로 모든 입력을 30초까지 패딩하여 일관된 입력 특징과 어텐션 마스크를 준비할 수 있습니다. 아래 예시를 참고하세요!

import torch
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor


processor = AutoProcessor.from_pretrained("nvidia/parakeet-ctc-1.1b")
model = AutoModelForCTC.from_pretrained("nvidia/parakeet-ctc-1.1b", device_map="auto")

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))
speech_samples = [el['array'] for el in ds["audio"][:5]]

# Compile the generate method with fullgraph and graph capture
model.generate = torch.compile(model.generate, fullgraph=True, mode="reduce-overhead")

# let's define processor kwargs to pad to 30 seconds
processor_kwargs = {
    "padding": "max_length",
    "max_length": 30 * processor.feature_extractor.sampling_rate,
}

# Define a timing context using accelerator events
class TimerContext:
    def __init__(self, name="Execution"):
        self.name = name
        self.start_event = None
        self.end_event = None

    def __enter__(self):
        # Use accelerator events for more accurate device timing
        self.start_event = torch.Event(enable_timing=True)
        self.end_event = torch.Event(enable_timing=True)
        self.start_event.record()
        return self

    def __exit__(self, *args):
        self.end_event.record()
        torch.accelerator.synchronize()
        elapsed_time = self.start_event.elapsed_time(self.end_event) / 1000.0
        print(f"{self.name} time: {elapsed_time:.4f} seconds")


inputs = processor(speech_samples[0], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("First generation - compiling...")
# Generate with the compiled model
with TimerContext("First generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[1], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Second generation - recording graphs...")
with TimerContext("Second generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[2], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Third generation - fast !!!")
with TimerContext("Third generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[3], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Fourth generation - still fast !!!")
with TimerContext("Fourth generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

CTC 학습

from datasets import Audio, load_dataset
from transformers import AutoModelForCTC, AutoProcessor

model_id = "nvidia/parakeet-ctc-1.1b"
NUM_SAMPLES = 5

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCTC.from_pretrained(model_id, device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

RNN-T 학습

RNN-T 손실을 계산하려면 torchaudio가 필요합니다(pip install torchaudio).

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision,  device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

TDT 학습

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

Transformers

Parakeet

개요

사용

ParakeetForCTC 사용

ParakeetForRNNT 사용

ParakeetForTDT 사용

모델을 빠르게 실행하기

CTC 학습

RNN-T 학습

TDT 학습

ParakeetTokenizer

클래스 transformers.ParakeetTokenizer

ParakeetFeatureExtractor

클래스 transformers.ParakeetFeatureExtractor

__call__

ParakeetProcessor

클래스 transformers.ParakeetProcessor

__call__

decode

ParakeetEncoderConfig

class transformers.ParakeetEncoderConfig

ParakeetCTCConfig

클래스 transformers.ParakeetCTCConfig

ParakeetRNNTConfig

클래스 transformers.ParakeetRNNTConfig

ParakeetTDTConfig

class transformers.ParakeetTDTConfig

ParakeetEncoder

class transformers.ParakeetEncoder

forward

ParakeetForCTC

class transformers.ParakeetForCTC

forward

generate

ParakeetForRNNT

클래스 transformers.ParakeetForRNNT

forward

ParakeetForTDT

class transformers.ParakeetForTDT

forward

call

call