Transformers documentation

Parakeet

Transformers

Başlayın

Transformers Kurulum Hızlı Başlangıç

Taban sınıfları

Modeller

Önişleyiciler

Çıkarım

Pipeline API

Generate API

Optimizasyon

Modellerle sohbet edin

Sunum

Eğitim

Başlayın

Özelleştirme

Parametre verimli ince ayar

Performans

Dağıtık eğitim

Donanım

Kantizasyon

Ekosistem entegrasyonları

Kaynaklar

API

Ana sınıflar

Modeller

Metin modelleri

Görüş modelleri

Ses modelleri

Video modelleri

Çok modlu modeller

Pekiştirmeli öğrenme modelleri

Zaman serisi modelleri

Dahili yardımcılar

Referans

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

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

Bu model, 2025-09-25 tarihinde Hugging Face Transformers'a katkıda bulunulmuştur.

Parakeet

Genel Bakış

NVIDIA NeMo tarafından tanıtılan Parakeet modelleri, otomatik konuşma tanıma için Fast Conformer kodlayıcıyı, bağlantısal zamansal sınıflandırma (CTC), yineleyli sinir ağı transdüser (RNNT) veya token ve süre transdüser (TDT) çözücüleriyle birleştiren modellerdir.

Model Mimarisi

Fast Conformer Encoder: Mel-spektrogram özelliklerini işleyen ve alt örnekleme yoluyla dizi uzunluğunu azaltan, doğrusal olarak ölçeklenebilir bir Conformer mimarisi. Bu, FastSpeech2Conformer içindeki Conformer Encoder'ın daha verimli bir versiyonudur (encoder uygulaması ve ayrıntılar için ParakeetEncoder'a bakın).
ParakeetForCTC: hızlı bir Conformer kodlayıcı + bir CTC çözücü
- CTC Decoder: Şu bileşenlerden oluşan basit ama etkili bir decoder:
  - Enkoder gizli boyutundan sözlük boyutuna 1D konvolüsyon projeksiyonu (optimal NeMo uyumluluğu için).
  - Eğitim için CTC kaybı hesaplama.
  - Çıkarım için açgözlü CTC çözümleme.
ParakeetForRNNT: hızlı Conformer kodlayıcı + RNN-T (RNN Transducer) çözücü
- RNN-T Decoder: Standart sinir transdüser:
  - LSTM tahmin ağı, token tahminleri arasında dil bağlamını korur.
  - Ortak ağ, kodlayıcı ve çözücü çıktılarını birleştirir.
  - Çıkarım için açgözlü transducer çözümleme: boş (blank) yayılımı, kodlayıcı çerçevesini bir adım ileri taşır; boş olmayan (non-blank) yayılımı ise aynı çerçevede kalır.
ParakeetForTDT: hızlı bir Conformer kodlayıcı + TDT (Token Süresi Transdüsü) çözücü
- TDT Decoder: Token'ları ve sürelerini birlikte tahmin ederek verimli çözümleme sağlar:
  - LSTM tahmin ağı, token tahminleri arasında dil bağlamını korur.
  - Ortak ağ, kodlayıcı ve çözücü çıktılarını birleştirir.
  - Duration head, atlaması gereken kare sayısını tahmin ederek hızlı çıkarımı (inference) sağlar.

Orijinal uygulama NVIDIA NeMo içinde bulunabilir. Model denetim noktaları NVIDIA organizasyonu altında yer almaktadır.

Bu model Nithin Rao Koluguri, Eustache Le Bihan, Eric Bezzam, Maksym Lypivskyi ve Hainan Xu tarafından katkıda bulunmuştur.

Kullanım

ParakeetForCTC kullanımı

Pipeline

AutoModel

ParakeetForRNNT kullanımı

Pipeline

AutoModel

Zaman Damgalama

Parakeet RNN-T, CTC gibi büyük/küçük harf ve noktalama işareti olmadan transkripsiyon yapar ve model ayrıca token zaman damgalama işlevini de gerçekleştirebilir.

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'nin aksine (her token için bir süre tahmin eder), her RNN-T token'ı tek bir kodlayıcı çerçevesinde üretilir; bu nedenle başlangıcı ve bitişi tam olarak bir çerçeveyi kapsar.

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 kullanımı

Pipeline

AutoModel

Zaman Damgalama

Modeli Hızlandırmak

Parakeet, grafik yakalama (NVIDIA GPU'larda CUDA graphs, diğer hızlandırıcılarda eşdeğer mekanizma) ile tam grafik derlemesini destekler! Bu optimizasyon, transkribe etmek istediğiniz maksimum ses uzunluğunu bildiğinizde en etkili sonucu verir. Temel fikir, yeniden derlemeyi önlemek için statik giriş biçimleri kullanmaktır. Örneğin, sesinizin 30 saniyeden kısa olacağını biliyorsanız, işlemciyi (processor) kullanarak tüm girişleri 30 saniyeye kadar doldurabilir (pad) ve tutarlı giriş özellikleri ile dikkat maskeleri (attention masks) hazırlayabilirsiniz. Aşağıdaki örneğe bakın!

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 Eğitimi

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 Eğitimi

RNN-T kaybının hesaplanması torchaudio gerektirir (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 Eğitimi

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

Genel Bakış

Kullanım

ParakeetForCTC kullanımı

ParakeetForRNNT kullanımı

ParakeetForTDT kullanımı

Modeli Hızlandırmak

CTC Eğitimi

RNN-T Eğitimi

TDT Eğitimi

ParakeetTokenizer

sınıf transformers.ParakeetTokenizer

ParakeetFeatureExtractor

sınıf transformers.ParakeetFeatureExtractor

__call__

ParakeetProcessor

sınıf transformers.ParakeetProcessor

__call__

decode

ParakeetEncoderConfig

sınıf transformers.ParakeetEncoderConfig

ParakeetCTCConfig

sınıf transformers.ParakeetCTCConfig

ParakeetRNNTConfig

sınıf transformers.ParakeetRNNTConfig

ParakeetTDTConfig

sınıf transformers.ParakeetTDTConfig

ParakeetEncoder

sınıf transformers.ParakeetEncoder

forward

ParakeetForCTC

sınıf transformers.ParakeetForCTC

forward

generate

ParakeetForRNNT

sınıf transformers.ParakeetForRNNT

forward

ParakeetForTDT

sınıf transformers.ParakeetForTDT

forward

call

call