# Parakeet

## Genel Bakış

NVIDIA NeMo tarafından [tanıtılan](https://developer.nvidia.com/blog/pushing-the-boundaries-of-speech-recognition-with-nemo-parakeet-asr-models/) Parakeet modelleri, otomatik konuşma tanıma için [Fast Conformer](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/asr/models.html#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](./fastspeech2_conformer) içindeki Conformer Encoder'ın daha verimli bir versiyonudur (encoder uygulaması ve ayrıntılar için [ParakeetEncoder](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetEncoder)'a bakın).
- [**ParakeetForCTC**](#parakeetforctc-usage): Hızlı Conformer Kodlayıcı + CTC Çözücü
  - **CTC Çözücü**: Şunlardan oluşan basit ama etkili çözücü:
    - 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**](#parakeetforrnnt-usage): Hızlı bir Conformer kodlayıcı + bir RNN-T (RNN Transducer) çözücü
  - **RNN-T Çözücü**: 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**](#parakeetfortdt-usage): Hızlı bir Conformer kodlayıcı + TDT (Token Duration Transducer) çözücü
  - **TDT Dekodlayıcı**: Tokenleri 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](https://github.com/NVIDIA/NeMo) içinde bulunabilir. Model denetim noktaları [NVIDIA kuruluşu](https://huggingface.co/nvidia/models?search=parakeet) altında yer almaktadır.

Bu model [Nithin Rao Koluguri](https://huggingface.co/nithinraok), [Eustache Le Bihan](https://huggingface.co/eustlb), [Eric Bezzam](https://huggingface.co/bezzam), [Maksym Lypivskyi](https://huggingface.co/MaksL) ve [Hainan Xu](https://huggingface.co/hainanx) tarafından katkıda bulunmuştur.

## Kullanım

### ParakeetForCTC kullanımı

```python
from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-ctc-1.1b")
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'}
```

```python
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor

model_id = "nvidia/parakeet-ctc-1.1b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCTC.from_pretrained(model_id, 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]]

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs)
print(processor.decode(outputs))
```

### ParakeetForRNNT kullanımı

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.

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

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

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"][:5]]

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)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

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.

```py
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ı

Parakeet TDT transkriptleri büyük/küçük harf bilgisini içerir ve model ayrıca token zaman damgalama işlemini de gerçekleştirebilir.

```py
from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-tdt-0.6b-v3")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'Yesterday it was 35 degrees in Barcelona, but today the temperature will go down to minus 20 degrees.'}
```

```py
from transformers import AutoModelForTDT, AutoProcessor
from datasets import load_dataset, Audio

model_id = "nvidia/parakeet-tdt-0.6b-v3"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, 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]]

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)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

```py
from datasets import Audio, load_dataset
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, 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.24, 'end': 0.48}, {'token': 'ister', 'start': 0.48, 'end': 0.64}, {'token': 'Qu', 'start': 0.64, 'end': 0.88}, {'token': 'il', 'start': 0.88, 'end': 1.12}, {'token': 'ter', 'start': 1.12, 'end': 1.36}, {'token': 'is', 'start': 1.36, 'end': 1.44}, {'token': 'the', 'start': 1.44, 'end': 1.6}, {'token': 'ap', 'start': 1.6, 'end': 1.76}, {'token': 'ost', 'start': 1.76, 'end': 1.92}, {'token': 'le', 'start': 2.0, 'end': 2.16}, {'token': 'of', 'start': 2.16, 'end': 2.24}, {'token': 'the', 'start': 2.24, 'end': 2.4}, {'token': 'mid', 'start': 2.4, 'end': 2.48}, {'token': 'd', 'start': 2.48, 'end': 2.56}, {'token': 'le', 'start': 2.56, 'end': 2.64}, {'token': 'clas', 'start': 2.72, 'end': 2.88}, {'token': 's', 'start': 2.88, 'end': 3.04}, {'token': 'es', 'start': 3.04, 'end': 3.12}, {'token': ',', 'start': 3.12, 'end': 3.12}, {'token': 'and', 'start': 3.2800000000000002, 'end': 3.44}, {'token': 'we', 'start': 3.44, 'end': 3.6}, {'token': 'are', 'start': 3.6, 'end': 3.7600000000000002}, {'token': 'gl', 'start': 3.7600000000000002, 'end': 3.92}, {'token': 'ad', 'start': 3.92, 'end': 4.08}, {'token': 'to', 'start': 4.08, 'end': 4.24}, {'token': 'wel', 'start': 4.24, 'end': 4.4}, {'token': 'c', 'start': 4.4, 'end': 4.48}, {'token': 'ome', 'start': 4.48, 'end': 4.72}, {'token': 'his', 'start': 4.72, 'end': 4.96}, {'token': 'gos', 'start': 4.96, 'end': 5.12}, {'token': 'pel', 'start': 5.36, 'end': 5.6000000000000005}, {'token': '.', 'start': 5.6000000000000005, 'end': 5.6000000000000005}]]
"""
```

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

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

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

> [!NOTE]
> RNN-T kaybının hesaplanması [torchaudio](https://pytorch.org/audio) gerektirir (`pip install torchaudio`).

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

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

## ParakeetTokenizer[[transformers.ParakeetTokenizer]]

#### transformers.ParakeetTokenizer[[transformers.ParakeetTokenizer]]

```python
transformers.ParakeetTokenizer(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/tokenization_parakeet.py#L20)

[PreTrainedTokenizerFast](/docs/transformers/main/tr/main_classes/tokenizer#transformers.TokenizersBackend) sınıfından tüm yöntemleri devralır. Kullanıcıların bu yöntemlerle ilgili daha fazla bilgi için bu üst sınıfa başvurması gerekir; ancak `_decode` yöntemi, CTC çözümlemesine uyarlanmak üzere yeniden tanımlanmıştır:
1. Arka arkaya gelen token'ları grupla
2. Boş token'ı filtrele

## ParakeetFeatureExtractor[[transformers.ParakeetFeatureExtractor]]

#### transformers.ParakeetFeatureExtractor[[transformers.ParakeetFeatureExtractor]]

```python
transformers.ParakeetFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L38)

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 80) : Çıkarılan özelliklerin boyutu.

sampling_rate (`int`, *opsiyonel*, varsayılan 16000) : Ses dosyalarının dijitalleştirileceği örneklem hızı, hertz (Hz) cinsinden ifade edilir.

hop_length (`int`, *opsiyonel*, varsayılan 160) : Mel Frekans katsayılarını elde etmek için kullanılan STFT'nin üst üste binen pencerelerinin uzunluğu.

n_fft (`int`, *isteğe bağlı*, varsayılan 512) : Fourier dönüşümünün boyutu.

win_length (`int`, *isteğe bağlı*, varsayılan 400) : STFT hesaplama için pencere uzunluğu.

preemphasis (`float`, *opsiyonel*, varsayılan 0.97) : Ön vurgulama (preemphasis) filtresi katsayısı. 0.0, ön vurgulama filtresinin uygulanmadığı anlamına gelir.

padding_value (`float`, *opsiyonel*, varsayılan 0.0) : Sesin doldurulmasında kullanılan dolgu değeri. Sessizliklere karşılık gelmelidir.

Bir Parakeet özellik çıkarıcısı oluşturur.

Bu özellik çıkarıcı, ana yöntemlerin çoğunu içeren [SequenceFeatureExtractor](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

Bu sınıf, ham konuşma verisinden mel-filtre bankası özelliklerini, pytorch'un `torch.stft` karşılığıyla eşleşmesi gereken özel bir numpy `Short Time Fourier Transform` uygulaması kullanarak çıkarır.

#### __call__[[transformers.ParakeetFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'longest', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', return_token_timestamps: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L129)

**Parametreler:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Dolgusu yapılacak dizi veya dizi partisi. Her dizi, bir numpy dizisi, bir float değerleri listesi, bir numpy dizileri listesi veya float değerleri listeleri listesi olabilir. Tek kanallı ses olmalıdır, stereo değil; yani her zaman adımı için tek bir float.

truncation (`bool`, *isteğe bağlı*, varsayılan `True`) : *max_length*'den uzun giriş dizilerini *max_length*'e kısaltmak için kesme işlemini etkinleştirir.

pad_to_multiple_of (`int`, *isteğe bağlı*, varsayılan değeri None) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Core'lerin kullanılmasını sağlamak veya 128'in katı olan dizi uzunluklarından faydalanan TPU'lar için özellikle faydalıdır.

return_attention_mask (`bool`, *isteğe bağlı*) : Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan bırakılırsa, ilgili feature_extractor'ın varsayılanına göre dikkat maskesi döndürülür.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)    Parakeet modelleri için, ince hatalardan kaçınmak adına toplu çıkarım (batched inference) sırasında `attention_mask` her zaman geçirilmelidir.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *isteğe bağlı*) : Ayarlanırsa, Python tamsayı listesi yerine tensörler döndürülür. Kabul edilen değerler:  - `'tf'`: TensorFlow `tf.constant` nesnelerini döndürür. - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: Numpy `np.ndarray` nesnelerini döndürür.

sampling_rate (`int`, *isteğe bağlı*) : `raw_speech` girdisinin örneklenmiş olduğu örneklem hızı. Sessiz hataları önlemek ve otomatik konuşma tanıma hattına izin vermek için forward çağrısında `sampling_rate` parametresinin geçirilmesi şiddetle önerilir.

padding_value (`float`, *isteğe bağlı*, varsayılan 0.0) : Dolgu değerleri / vektörleri doldurmak için kullanılan değer.

do_normalize (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdinin sıfır ortalama ve bir varyans ile normalize edilip edilmeyeceğini belirtir. Normalizasyon, model performansını önemli ölçüde iyileştirmeye yardımcı olabilir.

device (`str`, *isteğe bağlı*, varsayılan `'cpu'`) : `_torch_extract_fbank_features` yönteminde ses sinyallerinin log-mel spektrogramunun hesaplanması için kullanılan cihazı belirtir. (ör. "cpu", "cuda")

return_token_timestamps (`bool`, *isteğe bağlı*, varsayılan `None`) : Kullanımı durduruldu. Bunun yerine, kare sayısı çıkarılabilecek `return_attention_mask` parametresini kullanın. Girdi raw_speech'in kare sayısının döndürülüp döndürülmeyeceğini belirtir. Bu num_frames değerleri, model tarafından kelime düzeyi zaman damgalarının hesaplanmasında kullanılabilir.

Bir veya birden fazla diziyi model için özniteliklendirmek ve hazırlamak için kullanılan ana yöntem. Uygulama, kullanılabilirse STFT hesabı için PyTorch'u, aksi takdirde daha yavaş bir NumPy tabanlı yöntemi kullanır.

## ParakeetProcessor[[transformers.ParakeetProcessor]]

#### transformers.ParakeetProcessor[[transformers.ParakeetProcessor]]

```python
transformers.ParakeetProcessor(feature_extractor, tokenizer, blank_token = '<blank>', decoder_type = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L45)

**Parametreler:**

feature_extractor (`feature_extractor_class`) : Özellik çıkarıcı zorunlu bir girdidir.

tokenizer (`tokenizer_class`) : Tokenizer zorunlu bir girdidir.

blank_token (`str`, *isteğe bağlı*, varsayılan `"<blank>"`) : Transducer çözümleme için boş sembol.

decoder_type (`str`, *isteğe bağlı*) : Çözme/zaman damgası yayını modu. Olası değerler: - `"ctc"`: Ardışık aynı tokenlar tek bir yayında birleştirilir. - `"rnnt"`: Tekrarlanan tokenlar korunur; her token 1 karelik bir zaman damgası aralığı alır. - `"tdt"`: Tekrarlanan tokenlar korunur; her token aralığı tahmini süresine dayanır. Noktalama işaretleri önceki tokena eklenir. `None` ise (eski kontrol noktaları) geriye dönük uyumluluk için decoder tipi otomatik olarak çıkarılır.

Bir özellik çıkarıcıyı ve bir belirteçleyiciyi tek bir işlemciye saran bir ParakeetProcessor oluşturur.

[ParakeetProcessor](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetProcessor), `feature_extractor_class` ve `tokenizer_class` sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için `~feature_extractor_class` ve `~tokenizer_class` belgelerine bakın.

#### __call__[[transformers.ParakeetProcessor.__call__]]

```python
__call__(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 = None, sampling_rate: int | None = None, **kwargs: *<class 'transformers.models.parakeet.processing_parakeet.ParakeetProcessorKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L73)

**Parametreler:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Hazırlanacak ses veya sesler grubu. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

text (`Union[str, list[str], list[list[str]]]`, *isteğe bağlı*) : Kodlanacak dizi veya dizi topluluğu. Her dizi bir metin veya metin listesi (önceden tokenize edilmiş metin) olabilir. Önceden tokenize edilmiş bir girdi geçirirseniz, toplu girdilerle karışıklığı önlemek için `is_split_into_words=True` değerini ayarlayın.

sampling_rate (`int`, *isteğe bağlı*) : Girdi sesinin Hz cinsinden örneklem hızı. Bu, özellik çıkarıcısının beklediği örneklem hızıyla eşleşmelidir (varsayılan 16000 Hz). Sağlanırsa, işleyicinin beklediği örneklem hızıyla doğrulanır ve eşleşmezse bir hata oluşturulur. Sağlanmazsa bir uyarı verilir ve varsayılan örneklem hızı kabul edilir.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/tr/main_classes/processors#transformers.ProcessingKwargs), *opsiyonel*) : Her modalite (metin, görüntüler, videolar, ses) için ek işleme seçenekleri. Modelle ilgili parametreler yukarıda listelenmiştir; desteklenen argümanların tam listesi için TypedDict sınıfına bakın.

#### decode[[transformers.ParakeetProcessor.decode]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L132)

Argümanları [decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) işlevine iletin ve zaman damgalarını (TDT için sağlandıysa) NeMo kütüphanesindeki gibi son işlemleyin.

## ParakeetEncoderConfig[[transformers.ParakeetEncoderConfig]]

#### transformers.ParakeetEncoderConfig[[transformers.ParakeetEncoderConfig]]

```python
transformers.ParakeetEncoderConfig(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, is_encoder_decoder: bool = False, 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, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L23)

**Parametreler:**

hidden_size (`int`, *isteğe bağlı*, varsayılan `1024`) : Gizli temsillerin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `24`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `4096`) : MLP temsillerinin boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `silu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

convolution_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Conformer'ın konvolüsyon modülündeki konvolüsyonlarda bias kullanılıp kullanılmayacağı.

conv_kernel_size (`int`, *opsiyonel*, varsayılan 9) : Conformer bloğundaki konvolüsyon katmanlarının çekirdek boyutu.

subsampling_factor (`int`, *isteğe bağlı*, varsayılan 8) : Girdi dizisinin alt örneklenmesinde kullanılan çarpan.

subsampling_conv_channels (`int`, *isteğe bağlı*, varsayılan 256) : Alt örnekleme konvolüsyon katmanlarındaki kanal sayısı.

num_mel_bins (`int`, *isteğe bağlı*, varsayılan 80) : Mel özellik sayısı.

subsampling_conv_kernel_size (`int`, *isteğe bağlı*, varsayılan 3) : Alt örnekleme konvolüsyon katmanlarının çekirdek boyutu.

subsampling_conv_stride (`int`, *isteğe bağlı*, varsayılan 2) : Alt örneklemeli konvolüsyon katmanlarının adım boyutu (stride).

dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

dropout_positions (`float`, *opsiyonel*, varsayılan 0.0) : Girdi dizisindeki konumlar için dropout oranı.

layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `5000`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

scale_input (`bool`, *isteğe bağlı*, varsayılan `True`) : Girdi gömme değerlerinin ölçeklenip ölçeklenmeyeceğini belirtir.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

Bu, bir ParakeetModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Parakeet modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```python
>>> from transformers import ParakeetEncoderModel, ParakeetEncoderConfig

>>> # Initializing a `ParakeetEncoder` configuration
>>> configuration = ParakeetEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetEncoderModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ParakeetCTCConfig[[transformers.ParakeetCTCConfig]]

#### transformers.ParakeetCTCConfig[[transformers.ParakeetCTCConfig]]

```python
transformers.ParakeetCTCConfig(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, is_encoder_decoder: bool = False, 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, vocab_size: int = 1025, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = True, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int | None = 1024)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L91)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `1025`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

ctc_loss_reduction (`str`, *isteğe bağlı*, varsayılan `"mean"`) : `torch.nn.CTCLoss` çıktısına uygulanacak indirgemeyi belirtir. Yalnızca [ParakeetForCTC](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetForCTC) örneği eğitilirken geçerlidir.

ctc_zero_infinity (`bool`, *isteğe bağlı*, varsayılan `True`) : `torch.nn.CTCLoss`'ün sonsuz kayıplarını ve ilişkili gradyanlarını sıfırlayıp sıfırlamayacağını belirtir. Sonsuz kayıplar, girdilerin hedeflerle hizalanmak için çok kısa olması durumunda ortaya çıkar. Yalnızca bir [ParakeetForCTC](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetForCTC) örneği eğitilirken geçerlidir.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *isteğe bağlı*) : Kodlayıcının yapılandırma nesnesi veya sözlüğü.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `1024`) : Sözlükte dolgu için kullanılan token kimliği.

Bu, bir ParakeetModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Parakeet modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import ParakeetForCTC, ParakeetCTCConfig
>>> # Initializing a Parakeet configuration
>>> configuration = ParakeetCTCConfig()
>>> # Initializing a model from the configuration
>>> model = ParakeetForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## ParakeetRNNTConfig[[transformers.ParakeetRNNTConfig]]

#### transformers.ParakeetRNNTConfig[[transformers.ParakeetRNNTConfig]]

```python
transformers.ParakeetRNNTConfig(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 = 8193, 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 = 2, blank_token_id: int = 8192)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L134)

**Parametreler:**

is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı.

vocab_size (`int`, *isteğe bağlı*, varsayılan `8193`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

decoder_hidden_size (`int`, *isteğe bağlı*, varsayılan 640) : LSTM tahmin ağı ve ortak ağın gizli boyutu.

num_decoder_layers (`int`, *isteğe bağlı*, varsayılan 2) : Tahmin ağındaki LSTM katman sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `relu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_symbols_per_step (`int`, *isteğe bağlı*, varsayılan 10) : Açgözlü çözümleme sırasında her kodlayıcı zaman adımında çıkarılacak maksimum sembol sayısı.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *isteğe bağlı*) : Kodlayıcının yapılandırma nesnesi veya sözlüğü.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `2`) : Sözlükte dolgu için kullanılan token kimliği.

blank_token_id (`int`, *isteğe bağlı*, varsayılan 8192) : Boş jeton kimliği. RNN-T için `pad_token_id`'den farklıdır.

Bu, bir ParakeetModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Parakeet modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [nvidia/parakeet-rnnt-0.6b](https://huggingface.co/nvidia/parakeet-rnnt-0.6b) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```python
>>> from transformers import ParakeetForRNNT, ParakeetRNNTConfig

>>> # Initializing a Parakeet RNN-T configuration
>>> configuration = ParakeetRNNTConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetForRNNT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ParakeetTDTConfig[[transformers.ParakeetTDTConfig]]

#### transformers.ParakeetTDTConfig[[transformers.ParakeetTDTConfig]]

```python
transformers.ParakeetTDTConfig(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 = 8193, 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 = 2, blank_token_id: int = 8192, durations: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4))
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L182)

**Parametreler:**

is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı.

vocab_size (`int`, *isteğe bağlı*, varsayılan `8193`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

decoder_hidden_size (`int`, *isteğe bağlı*, varsayılan 640) : LSTM tahmin ağı ve ortak ağın gizli boyutu.

num_decoder_layers (`int`, *isteğe bağlı*, varsayılan 2) : Tahmin ağındaki LSTM katman sayısı.

hidden_act (`str`, *isteğe bağlı*, varsayılan `relu`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_symbols_per_step (`int`, *isteğe bağlı*, varsayılan 10) : Açgözlü çözümleme sırasında her kodlayıcı zaman adımında çıkarılacak maksimum sembol sayısı.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *isteğe bağlı*) : Kodlayıcının yapılandırma nesnesi veya sözlüğü.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `2`) : Sözlükte dolgu için kullanılan token kimliği.

blank_token_id (`int`, *isteğe bağlı*, varsayılan 8192) : Boş jeton kimliği. TDT için `pad_token_id`'den farklıdır.

durations (`list[int]`, *isteğe bağlı*, varsayılan `[0, 1, 2, 3, 4]`) : Tahmin edilebilen token süre değerleri. Her değer, bir token veya boş yayılımının kaç kare sürdüğünü temsil eder.

Bu, bir ParakeetModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Parakeet modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [nvidia/parakeet-tdt-0.6b-v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:
```python
>>> from transformers import ParakeetForTDT, ParakeetTDTConfig

>>> # Initializing a Parakeet TDT configuration
>>> configuration = ParakeetTDTConfig()

>>> # Initializing a model from the configuration
>>> model = ParakeetForTDT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ParakeetEncoder[[transformers.ParakeetEncoder]]

#### transformers.ParakeetEncoder[[transformers.ParakeetEncoder]]

```python
transformers.ParakeetEncoder(config: ParakeetEncoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L534)

**Parametreler:**

config ([ParakeetEncoderConfig](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetEncoderConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

[Fast Conformer mimarisi](https://huggingface.co/papers/2305.05084) tabanlı Parakeet Encoder modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.ParakeetEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attention_mask: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L557)

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

output_attention_mask (`bool`, *isteğe bağlı*, varsayılan `True`) : Çıktı dikkat maskesinin döndürülüp döndürülmeyeceğini belirtir. Yalnızca `attention_mask` sağlandığında etkilidir.

**Dönüş:** [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)`

Bir [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[ParakeetEncoder](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetEncoder) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

```python
>>> from transformers import AutoProcessor, ParakeetEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = ParakeetEncoder.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)
```

## ParakeetForCTC[[transformers.ParakeetForCTC]]

#### transformers.ParakeetForCTC[[transformers.ParakeetForCTC]]

```python
transformers.ParakeetForCTC(config: ParakeetCTCConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L679)

**Parametreler:**

config ([ParakeetCTCConfig](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetCTCConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Bağlantılı Zaman Sınıflandırma (CTC) başlığına sahip Parakeet Kodlayıcı.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.ParakeetForCTC.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L690)

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

labels (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı veya -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

**Dönüş:** [CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya `tuple(torch.Tensor)`

Bir [CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[ParakeetForCTC](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetForCTC) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı (sonraki token tahmini için).
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

```python
>>> from transformers import AutoProcessor, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.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"], text=ds[0]["text"])
>>> outputs = model(**inputs)

>>> print(outputs.loss)
```

#### generate[[transformers.ParakeetForCTC.generate]]

```python
generate(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, return_dict_in_generate: bool = False, compile_config: transformers.generation.configuration_utils.CompileConfig | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L750)

compile_config ([CompileConfig](/docs/transformers/main/tr/internal/generation_utils#transformers.CompileConfig), *isteğe bağlı*): Sağlanırsa, `torch.compile`, çözümleme döngüsündeki ileri çağrılara uygulanır.

Örnek:

```python
>>> from transformers import AutoProcessor, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.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"], text=ds[0]["text"])
>>> predicted_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> print(transcription)
```

## ParakeetForRNNT[[transformers.ParakeetForRNNT]]

#### transformers.ParakeetForRNNT[[transformers.ParakeetForRNNT]]

```python
transformers.ParakeetForRNNT(config: ParakeetRNNTConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L902)

**Parametreler:**

config ([ParakeetRNNTConfig](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetRNNTConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

RNN-T (RNN Transducer) başlığına sahip Parakeet Encoder.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.ParakeetForRNNT.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.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L932)

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, 1)`, *isteğe bağlı*) : Tek adımlı çıkarım için decoder giriş token kimlikleri.

decoder_cache (`ParakeetRNNTDecoderCache`, *isteğe bağlı*) : Decoder LSTM önbelleği. Sağlandığında ve başlatıldığında, önbelleğe alınan `decoder_output` (ör. boşluk atlaması sırasında) decoder'ın çalıştırılması yerine yeniden kullanılır. `input_ids` sağlandığında decoder çalışır ve önbellek yerinde güncellenir.

use_decoder_cache (`bool`, *isteğe bağlı*) : Bir decoder önbelleğinin kullanılıp kullanılmayacağını belirtir. `True` ve `decoder_cache` `None` ise, ileri geçiş sırasında yeni bir önbellek otomatik olarak oluşturulur.

encoder_outputs (`tuple(torch.Tensor)`, *isteğe bağlı*) : Ön hesaplanmış kodlayıcı çıktıları (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Bir tuple veya `ParakeetEncoderModelOutput` olabilir.

labels (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı veya -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

**Dönüş:** `ParakeetRNNTOutput` veya `tuple(torch.Tensor)`

`ParakeetRNNTOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[ParakeetForRNNT](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetForRNNT) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, *isteğe bağlı*) -- `labels` sağlandığında döndürülen RNN-T kaybı.
- **logits** (`torch.Tensor`) -- Ortak token logits. Eğitim için şekli `(batch, T, U+1, vocab)`, tek adımlı çıkarım için ise `(batch, 1, 1, vocab)` şeklindedir.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *opsiyonel*) -- Gizli durum, hücre durumu ve son çıktıyı içeren decoder LSTM önbelleği.

Örnek:

```python
>>> from transformers import AutoProcessor, ParakeetForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-rnnt-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForRNNT.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)
```

## ParakeetForTDT[[transformers.ParakeetForTDT]]

#### transformers.ParakeetForTDT[[transformers.ParakeetForTDT]]

```python
transformers.ParakeetForTDT(config: ParakeetTDTConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1032)

**Parametreler:**

config ([ParakeetTDTConfig](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetTDTConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

TDT (Token Duration Transducer) başlığına sahip Parakeet Encoder.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.ParakeetForTDT.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.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1041)

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, 1)`, *isteğe bağlı*) : Tek adımlı çıkarım için decoder giriş token kimlikleri.

decoder_cache (`ParakeetRNNTDecoderCache`, *isteğe bağlı*) : Decoder LSTM önbelleği. Sağlandığında ve başlatıldığında, önbelleğe alınan `decoder_output` (ör. boşluk atlaması sırasında) decoder'ın çalıştırılması yerine yeniden kullanılır. `input_ids` sağlandığında decoder çalışır ve önbellek yerinde güncellenir.

use_decoder_cache (`bool`, *isteğe bağlı*) : Bir decoder önbelleğinin kullanılıp kullanılmayacağını belirtir. `True` ve `decoder_cache` `None` ise, ileri geçiş sırasında yeni bir önbellek otomatik olarak oluşturulur.

encoder_outputs (`tuple(torch.Tensor)`, *isteğe bağlı*) : Ön hesaplanmış kodlayıcı çıktıları (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Bir tuple veya `ParakeetEncoderModelOutput` olabilir.

labels (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı veya -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

**Dönüş:** `ParakeetRNNTOutput` veya `tuple(torch.Tensor)`

`ParakeetRNNTOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya (`None`) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[ParakeetForTDT](/docs/transformers/main/tr/model_doc/parakeet#transformers.ParakeetForTDT) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, *isteğe bağlı*) -- `labels` sağlandığında döndürülen RNN-T kaybı.
- **logits** (`torch.Tensor`) -- Ortak token logits. Eğitim için şekli `(batch, T, U+1, vocab)`, tek adımlı çıkarım için ise `(batch, 1, 1, vocab)` şeklindedir.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *opsiyonel*) -- Gizli durum, hücre durumu ve son çıktıyı içeren decoder LSTM önbelleği.

Örnek:

```python
>>> from transformers import AutoProcessor, ParakeetForTDT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-tdt-0.6b-v3"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForTDT.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)
```