Transformers documentation

Parakeet

Transformers

Bắt đầu

Transformers Cài đặt Bắt đầu nhanh

Lớp cơ sở

Mô hình

Bộ tiền xử lý

Suy luận

Pipeline API

Tạo API

Tối ưu hóa

Trò chuyện với các model

Serving

Huấn luyện

Bắt đầu

Tùy chỉnh

Tinh chỉnh hiệu quả tham số

Hiệu năng

Huấn luyện phân tán

Phần cứng

Lượng tử hóa

Tích hợp hệ sinh thái

Tài nguyên

API

Các lớp chính

Mô hình

Mô hình văn bản

Mô hình thị giác

Mô hình âm thanh

Mô hình video

Mô hình đa phương thức

Mô hình học tăng cường

Mô hình chuỗi thời gian

Hàm trợ giúp nội bộ

Tham khảo

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

Mô hình này đã được đóng góp cho Hugging Face Transformers vào ngày 2025-09-25.

Parakeet

Tổng quan

Các mô hình Parakeet, được giới thiệu bởi NVIDIA NeMo, là các mô hình kết hợp bộ mã hóa Fast Conformer với bộ giải mã phân loại thời gian kết nối (CTC), transducer mạng nơ-ron hồi quy (RNNT) hoặc transducer token và thời lượng (TDT) cho nhận dạng giọng nói tự động.

Kiến trúc Mô hình

Fast Conformer Encoder: Kiến trúc Conformer có khả năng mở rộng tuyến tính, xử lý các đặc trưng mel-spectrogram và giảm độ dài chuỗi thông qua hạ mẫu. Đây là phiên bản hiệu quả hơn của Conformer Encoder có trong FastSpeech2Conformer (xem ParakeetEncoder để biết chi tiết về cài đặt và thông tin của encoder).
ParakeetForCTC: một Fast Conformer Encoder + một bộ giải mã CTC
- CTC Decoder: Bộ giải mã đơn giản nhưng hiệu quả, bao gồm:
  - Chiếu tích chập 1 chiều từ kích thước ẩn của bộ mã hóa sang kích thước từ vựng (để tương thích tối ưu với NeMo).
  - Tính toán tổn thất CTC cho huấn luyện.
  - Giải mã CTC tham lam cho suy luận.
ParakeetForRNNT: một Fast Conformer Encoder + một decoder RNN-T (RNN Transducer)
- RNN-T Decoder: Transducer thần kinh tiêu chuẩn:
  - Mạng dự đoán LSTM duy trì ngữ cảnh ngôn ngữ xuyên suốt các dự đoán token.
  - Mạng kết hợp (Joint network) kết hợp đầu ra của bộ mã hóa và bộ giải mã.
  - Giải mã transducer tham lam cho suy luận: một phát xạ blank (trống) sẽ tiến bộ mã hóa (encoder) lên một khung, trong khi một phát xạ không-blank sẽ giữ nguyên ở cùng một khung.
ParakeetForTDT: một Fast Conformer Encoder + một TDT (Token Duration Transducer) decoder
- TDT Decoder: Dự đoán đồng thời các token và thời lượng của chúng, cho phép giải mã hiệu quả:
  - Mạng dự đoán LSTM duy trì ngữ cảnh ngôn ngữ xuyên suốt các dự đoán token.
  - Mạng kết hợp (Joint network) kết hợp đầu ra của bộ mã hóa và bộ giải mã.
  - Duration head dự đoán số khung hình cần bỏ qua, cho phép suy luận nhanh.

Bản triển khai gốc có thể được tìm thấy trong NVIDIA NeMo. Các checkpoint của mô hình có thể được tìm thấy dưới tổ chức NVIDIA.

Mô hình này được đóng góp bởi Nithin Rao Koluguri, Eustache Le Bihan, Eric Bezzam, Maksym Lypivskyi và Hainan Xu.

Cách sử dụng

Cách sử dụng ParakeetForCTC

Pipeline

AutoModel

Cách sử dụng ParakeetForRNNT

Pipeline

AutoModel

Đóng dấu thời gian

Parakeet RNN-T chuyển văn bản thành chữ mà không phân biệt hoa thường hay dấu câu (giống CTC), và mô hình cũng có thể thực hiện gắn mốc thời gian cho từng token.

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

Khác với TDT (dự đoán thời lượng cho từng token), mỗi token RNN-T được phát ra tại một khung encoder duy nhất, do đó khoảng thời gian bắt đầu và kết thúc của nó chính xác bằng một khung.

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}]]
"""

Cách sử dụng ParakeetForTDT

Pipeline

AutoModel

Đóng dấu thời gian

Đẩy Mô Hình Chạy Nhanh Hơn

Parakeet hỗ trợ biên dịch toàn bộ đồ thị với cơ chế bắt đồ thị (CUDA graphs trên GPU NVIDIA, và cơ chế tương đương trên các bộ tăng tốc khác)! Tối ưu hóa này hiệu quả nhất khi bạn biết độ dài tối đa của âm thanh cần chuyển thành văn bản. Ý tưởng chính là sử dụng hình dạng đầu vào tĩnh để tránh biên dịch lại. Ví dụ, nếu bạn biết âm thanh của mình sẽ dưới 30 giây, bạn có thể dùng processor để đệm tất cả các đầu vào lên 30 giây, chuẩn bị các đặc trưng đầu vào và attention masks nhất quán. Xem ví dụ bên dưới!

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

Huấn luyện 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()

Huấn luyện RNN-T

Việc tính toán tổn thất RNN-T yêu cầu 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()

Huấn luyện 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

Tổng quan

Cách sử dụng

Cách sử dụng ParakeetForCTC

Cách sử dụng ParakeetForRNNT

Cách sử dụng ParakeetForTDT

Đẩy Mô Hình Chạy Nhanh Hơn

Huấn luyện CTC

Huấn luyện RNN-T

Huấn luyện TDT

ParakeetTokenizer

lớp transformers.ParakeetTokenizer

ParakeetFeatureExtractor

lớp transformers.ParakeetFeatureExtractor

__call__

ParakeetProcessor

lớp transformers.ParakeetProcessor

__call__

decode

ParakeetEncoderConfig

lớp transformers.ParakeetEncoderConfig

ParakeetCTCConfig

lớp transformers.ParakeetCTCConfig

ParakeetRNNTConfig

lớp transformers.ParakeetRNNTConfig

ParakeetTDTConfig

lớp transformers.ParakeetTDTConfig

ParakeetEncoder

lớp transformers.ParakeetEncoder

forward

ParakeetForCTC

lớp transformers.ParakeetForCTC

forward

generate

ParakeetForRNNT

lớp transformers.ParakeetForRNNT

forward

ParakeetForTDT

lớp transformers.ParakeetForTDT

forward

call

call