# Parakeet

## Обзор

Модели Parakeet, [представленные NVIDIA NeMo](https://developer.nvidia.com/blog/pushing-the-boundaries-of-speech-recognition-with-nemo-parakeet-asr-models/), представляют собой модели, сочетающие энкодер [Fast Conformer](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/asr/models.html#fast-conformer) с декодером для автоматического распознавания речи на основе connectionist temporal classification (CTC), recurrent neural network transducer (RNNT) или token and duration transducer (TDT).

**Архитектура модели**

- **Fast Conformer Encoder**: линейно масштабируемая архитектура Conformer, обрабатывающая признаки мел-спектрограммы и сокращающая длину последовательности за счёт подвыборки. Это более эффективная версия Conformer Encoder, используемого в [FastSpeech2Conformer](./fastspeech2_conformer) (см. [ParakeetEncoder](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetEncoder) для реализации и подробностей по энкодеру).
- [**ParakeetForCTC**](#parakeetforctc-usage): быстрый Conformer-энкодер + CTC-декодер
  - **Декодер CTC**: простой, но эффективный декодер, состоящий из:
    - 1D-свёрточная проекция из скрытого размера энкодера в размер словаря (для оптимальной совместимости с NeMo).
    - Вычисление функции потерь CTC для обучения.
    - Жадное CTC-декодирование для инференса.
- [**ParakeetForRNNT**](#parakeetforrnnt-usage): быстрый Conformer-энкодер + декодер RNN-T (RNN Transducer)
  - **Декодер RNN-T**: стандартный нейронный трансдьюсер:
    - Сеть предсказания LSTM сохраняет языковой контекст при предсказании токенов.
    - Совместная сеть объединяет выходы кодировщика и декодера.
    - Жадное декодирование трансдуктора для инференса: эмиссия blank сдвигает кадр энкодера на один, а эмиссия не-blank оставляет позицию на том же кадре.
- [**ParakeetForTDT**](#parakeetfortdt-usage): быстрый Conformer-энкодер + декодер TDT (Token Duration Transducer)
  - **Декодер TDT**: совместно предсказывает токены и их длительности, обеспечивая эффективное декодирование:
    - Сеть предсказания LSTM сохраняет языковой контекст при предсказании токенов.
    - Совместная сеть объединяет выходы кодировщика и декодера.
    - Головка длительности предсказывает, сколько кадров пропустить, что обеспечивает быстрый вывод.

Оригинальная реализация доступна в [NVIDIA NeMo](https://github.com/NVIDIA/NeMo). Контрольные точки моделей находятся в [организации NVIDIA](https://huggingface.co/nvidia/models?search=parakeet).

Эта модель была предоставлена [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) и [Hainan Xu](https://huggingface.co/hainanx).

## Использование

### Использование ParakeetForCTC

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

Parakeet RNN-T выполняет транскрибацию без учёта регистра и пунктуации (как CTC), а также модель поддерживает присвоение временных меток токенам.

```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 (который предсказывает длительность для каждого токена), каждый токен RNN-T издается в рамках одного кадра энкодера, поэтому его начало и конец занимают ровно один кадр.

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

Транскрипты Parakeet TDT содержат регистр символов, а модель также может выполнять временнóе маркирование токенов.

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

### Ускоряем модель

Parakeet поддерживает компиляцию полного графа с захватом графа (CUDA graphs на GPU NVIDIA и аналогичный механизм на других ускорителях)! Эта оптимизация наиболее эффективна, если вы знаете максимальную длину аудио, которую хотите распознать. Ключевая идея заключается в использовании статических форм входных данных для избежания повторной компиляции. Например, если вы знаете, что ваше аудио короче 30 секунд, вы можете использовать процессор, чтобы дополнить все входные данные до 30 секунд, подготовив согласованные входные признаки и маски внимания. См. пример ниже!

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

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

> [!NOTE]
> Вычисление потерь RNN-T требует [torchaudio](https://pytorch.org/audio) (`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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/tokenization_parakeet.py#L20)

Наследует все методы из [PreTrainedTokenizerFast](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend). За дополнительной информацией о них следует обращаться к этому суперклассу, за исключением `_decode`, который переопределён для адаптации к декодированию CTC:
1. Группировка последовательных токенов
2. Отфильтруйте пустой токен

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L36)

**Параметры:**

feature_size (`int`, *optional*, по умолчанию 80) : Размерность признаков извлекаемых фич.

sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц).

hop_length (`int`, *optional*, по умолчанию 160) : Длина перекрывающихся окон для STFT, используемой для получения коэффициентов Мел-частот.

n_fft (`int`, *необязательный*, по умолчанию 512) : Размер преобразования Фурье.

win_length (`int`, *optional*, по умолчанию 400) : Длина окна для вычисления STFT.

preemphasis (`float`, *optional*, по умолчанию 0.97) : Коэффициент фильтра предварительного усиления. Значение 0.0 означает отсутствие фильтра предварительного усиления.

padding_value (`float`, *optional*, по умолчанию 0.0) : Значение, используемое для дополнения аудио. Должно соответствовать тишине.

Создаёт экстрактор признаков Parakeet.

Этот экстрактор признаков наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), который содержит большинство основных методов. За дополнительной информацией о них следует обращаться к этому суперклассу.

Этот класс извлекает характеристики банка мел-фильтров из исходной речи с помощью собственной реализации `Short Time Fourier Transform` на numpy, которая должна совпадать с эквивалентом `torch.stft` в pytorch.

#### __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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/feature_extraction_parakeet.py#L122)

**Параметры:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Последовательность или батч последовательностей, для которых требуется выравнивание. Каждая последовательность может быть массивом numpy, списком значений float, списком массивов numpy или списком списков значений float. Аудио должно быть моноканальным, а не стерео, то есть одно значение float на временной шаг.

truncation (`bool`, *необязательный*, по умолчанию `True`) : Включает усечение, чтобы обрезать входные последовательности длиннее *max_length* до *max_length*.

pad_to_multiple_of (`int`, *optional*, по умолчанию None) : Если задано, последовательность будет дополнена нулями до кратного указанного значения. Это особенно полезно для использования Tensor Cores на оборудовании NVIDIA с вычислительной способностью `>= 7.5` (Volta) или на TPU, где производительность повышается при длине последовательности, кратной 128.

return_attention_mask (`bool`, *необязательный*) : Нужно ли возвращать маску внимания. Если значение не указано, маска внимания будет возвращена в соответствии со значением по умолчанию конкретного feature_extractor.  [Что такое маски внимания?](../glossary#attention-mask)    Для моделей Parakeet `attention_mask` следует всегда передавать при пакетном выводе, чтобы избежать тонких ошибок.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *необязательный*) : Если задано, возвращает тензоры вместо списка целых чисел Python. Допустимые значения:  - `'tf'`: Возвращает объекты `tf.constant` TensorFlow. - `'pt'`: Возвращает объекты `torch.Tensor` PyTorch. - `'np'`: Возвращает объекты `np.ndarray` Numpy.

sampling_rate (`int`, *optional*) : Частота дискретизации, с которой вход `raw_speech` был оцифрован. Настоятельно рекомендуется передавать `sampling_rate` при вызове forward, чтобы избежать скрытых ошибок и обеспечить работу конвейера автоматического распознавания речи.

padding_value (`float`, *необязательный*, по умолчанию 0.0) : Значение, используемое для заполнения значений/векторов отступов.

do_normalize (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли нормализовать входные данные до нулевого среднего и единичной дисперсии. Нормализация может значительно повысить производительность модели.

device (`str`, *необязательный*, по умолчанию `'cpu'`) : Указывает устройство для вычисления лог-мел-спектрограммы аудиосигналов в методе `_torch_extract_fbank_features`. (например, "cpu", "cuda")

return_token_timestamps (`bool`, *необязательный*, по умолчанию `None`) : Устарело. Вместо этого используйте `return_attention_mask`, из которого можно вывести количество кадров. Определяет, следует ли возвращать количество кадров входного raw_speech. Эти num_frames могут использоваться моделью для вычисления временных меток на уровне слов.

Основной метод для извлечения признаков и подготовки одной или нескольких последовательностей для модели. Реализация использует PyTorch для вычисления STFT, если он доступен, в противном случае — более медленный вариант на основе NumPy.

## ParakeetProcessor[[transformers.ParakeetProcessor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L29)

**Параметры:**

feature_extractor (`feature_extractor_class`) : Извлечение признаков является обязательным входом.

tokenizer (`tokenizer_class`) : Токенизатор является обязательным входным параметром.

blank_token (`str`, *необязательный*, по умолчанию `"<blank>"`) : Пустой токен для декодирования трансдуктора.

decoder_type (`str`, *optional*) : Режим декодирования/эмиссии временных меток. Возможные значения:  - `"ctc"`: Последовательные идентичные токены объединяются в одну эмиссию. - `"rnnt"`: Повторяющиеся токены сохраняются; каждому токену присваивается диапазон временной метки в 1 кадр. - `"tdt"`: Повторяющиеся токены сохраняются; диапазон каждого токена основан на его прогнозируемой длительности. Пунктуация привязывается к предшествующему токену.  Если `None` (более старые контрольные точки), тип декодера определяется автоматически для обратной совместимости.

Создаёт ParakeetProcessor, который объединяет feature extractor и tokenizer в единый processor.

[ParakeetProcessor](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetProcessor) предоставляет все возможности `feature_extractor_class` и `tokenizer_class`. Подробнее см. в `~feature_extractor_class` и `~tokenizer_class`.

#### __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.processing_utils.ProcessingKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L70)

**Параметры:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Аудио или пакет аудио, подлежащий подготовке. Каждое аудио может быть массивом NumPy или тензором PyTorch. В случае массива NumPy/тензора PyTorch каждое аудио должно иметь форму (C, T), где C — количество каналов, а T — длина выборки аудио.

text (`Union[str, list[str], list[list[str]]]`, *необязательный*) : Последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаёте предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами.

sampling_rate (`int`, *optional*) : Частота дискретизации входного аудио в Гц. Она должна совпадать с частотой дискретизации, ожидаемой экстрактором признаков (по умолчанию 16000 Гц). Если значение указано, оно проверяется на соответствие ожидаемой частоте дискретизации процессора, и при несовпадении возникает ошибка. Если значение не указано, выводится предупреждение, и предполагается частота дискретизации по умолчанию.

return_mm_token_type_ids (`bool`, *kwargs*) : Нужно ли возвращать идентификаторы типов мультимодальных токенов, указывающие на позиции мультимодальных плейсхолдер-токенов.

return_text_replacement_offsets (`bool`, *kwargs*) : Нужно ли возвращать смещения символов для каждого мультимодального плейсхолдера и его замены.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/processing_parakeet.py#L128)

Передайте аргументы в [decode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) и выполните постобработку временных меток (если они предоставлены для TDT) аналогично библиотеке NeMo.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L23)

**Параметры:**

hidden_size (`int`, *необязательный*, по умолчанию `1024`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `24`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *необязательный*, по умолчанию `4096`) : Размерность представлений MLP.

hidden_act (`str`, *необязательный*, по умолчанию `silu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

attention_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

convolution_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в свертках модуля свертки conformer.

conv_kernel_size (`int`, *optional*, по умолчанию 9) : Размер ядра свёрточных слоёв в блоке Conformer.

subsampling_factor (`int`, *optional*, по умолчанию 8) : Коэффициент, на который выполняется подвыборка входной последовательности.

subsampling_conv_channels (`int`, *необязательный*, по умолчанию 256) : Количество каналов в слоях свёртки с подвыборкой.

num_mel_bins (`int`, *optional*, по умолчанию 80) : Количество мел-признаков.

subsampling_conv_kernel_size (`int`, *optional*, по умолчанию 3) : Размер ядра для свёрточных слоёв подвыборки.

subsampling_conv_stride (`int`, *optional*, по умолчанию 2) : Шаг (stride) для свёрточных слоёв подвыборки.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

dropout_positions (`float`, *необязательный*, по умолчанию 0.0) : Коэффициент dropout для позиций во входной последовательности.

layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность LayerDrop. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556).

activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Коэффициент dropout для активаций внутри полносвязного слоя.

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания.

max_position_embeddings (`int`, *необязательный*, по умолчанию `5000`) : Максимальная длина последовательности, с которой может использоваться эта модель.

scale_input (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли масштабировать входные эмбеддинги.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

Это класс конфигурации для хранения настроек модели ParakeetModel. Он используется для создания модели Parakeet в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:
```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L91)

**Параметры:**

vocab_size (`int`, *необязательный*, по умолчанию `1025`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

ctc_loss_reduction (`str`, *необязательный*, по умолчанию `"mean"`) : Указывает тип агрегации, применяемый к выходу `torch.nn.CTCLoss`. Актуально только при обучении экземпляра [ParakeetForCTC](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetForCTC).

ctc_zero_infinity (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли обнулять бесконечные потери и связанные с ними градиенты `torch.nn.CTCLoss`. Бесконечные потери возникают в основном, когда входные последовательности слишком короткие для выравнивания с целевыми. Параметр актуален только при обучении экземпляра [ParakeetForCTC](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetForCTC).

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *необязательный*) : Объект конфигурации или словарь для энкодера.

pad_token_id (`int`, *необязательный*, по умолчанию `1024`) : Идентификатор токена, используемый для выравнивания в словаре.

Это класс конфигурации для хранения настроек модели ParakeetModel. Он используется для создания модели Parakeet в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L134)

**Параметры:**

is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера.

vocab_size (`int`, *необязательный*, по умолчанию `8193`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

decoder_hidden_size (`int`, *optional*, по умолчанию 640) : Размер скрытого слоя сети предсказания LSTM и объединённой сети.

num_decoder_layers (`int`, *необязательный*, по умолчанию 2) : Количество слоёв LSTM в сети предсказания.

hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

max_symbols_per_step (`int`, *optional*, по умолчанию 10) : Максимальное количество символов, выдаваемых на каждом временном шаге энкодера при жадном декодировании.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *необязательный*) : Объект конфигурации или словарь для энкодера.

pad_token_id (`int`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемый для выравнивания в словаре.

blank_token_id (`int`, *optional*, по умолчанию 8192) : Идентификатор пустого токена. Отличается от `pad_token_id` для RNN-T.

Это класс конфигурации для хранения настроек модели ParakeetModel. Он используется для создания модели Parakeet в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [nvidia/parakeet-rnnt-0.6b](https://huggingface.co/nvidia/parakeet-rnnt-0.6b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:
```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))
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/configuration_parakeet.py#L182)

**Параметры:**

is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера.

vocab_size (`int`, *необязательный*, по умолчанию `8193`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

decoder_hidden_size (`int`, *optional*, по умолчанию 640) : Размер скрытого слоя сети предсказания LSTM и объединённой сети.

num_decoder_layers (`int`, *необязательный*, по умолчанию 2) : Количество слоёв LSTM в сети предсказания.

hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

max_symbols_per_step (`int`, *optional*, по умолчанию 10) : Максимальное количество символов, выдаваемых на каждом временном шаге энкодера при жадном декодировании.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *необязательный*) : Объект конфигурации или словарь для энкодера.

pad_token_id (`int`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемый для выравнивания в словаре.

blank_token_id (`int`, *необязательный*, по умолчанию 8192) : Идентификатор пустого токена. Отличается от `pad_token_id` для TDT.

durations (`list[int]`, *необязательный*, по умолчанию `[0, 1, 2, 3, 4]`) : Значения длительности токенов, которые могут быть предсказаны. Каждое значение представляет собой количество кадров, на которые распространяется токен или эмиссия пробела.

Это класс конфигурации для хранения настроек модели ParakeetModel. Он используется для создания модели Parakeet в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [nvidia/parakeet-tdt-0.6b-v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:
```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L536)

**Параметры:**

config ([ParakeetEncoderConfig](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetEncoderConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Parakeet Encoder, основанная на архитектуре [Fast Conformer](https://huggingface.co/papers/2305.05084).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L559)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

output_attention_mask (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли возвращать маску внимания на выходе. Действует только при передаче `attention_mask`.

**Возвращает:** [BaseModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [ParakeetEncoder](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetEncoder) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L681)

**Параметры:**

config ([ParakeetCTCConfig](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetCTCConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Кодировщик Parakeet с головой Connectionist Temporal Classification (CTC).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L692)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

labels (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

**Возвращает:** [CausalLMOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutput) или `tuple(torch.Tensor)`

[CausalLMOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [ParakeetForCTC](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetForCTC) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L752)

compile_config ([CompileConfig](/docs/transformers/main/ru/internal/generation_utils#transformers.CompileConfig), *необязательный*): если указан, `torch.compile` будет применяться к вызовам forward в цикле декодирования.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L904)

**Параметры:**

config ([ParakeetRNNTConfig](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetRNNTConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Кодировщик Parakeet с головой RNN-T (RNN Transducer).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L934)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, 1)`, *необязательный*) : Идентификаторы входных токенов декодера для одношагового вывода.

decoder_cache (`ParakeetRNNTDecoderCache`, *необязательный*) : Кэш LSTM декодера. Если передан и инициализирован, кэшированный `decoder_output` переиспользуется (например, при пропуске пустых токенов) вместо запуска декодера. Если передан `input_ids`, декодер выполняется, и кэш обновляется на месте.

use_decoder_cache (`bool`, *необязательный*) : Использовать ли кэш декодера. Если `True` и `decoder_cache` равно `None`, новый кэш создаётся автоматически во время прямого прохода.

encoder_outputs (`tuple(torch.Tensor)`, *необязательный*) : Предварительно вычисленные выходные данные энкодера (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Может быть кортежем или `ParakeetEncoderModelOutput`.

labels (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

**Возвращает:** `ParakeetRNNTOutput` или `tuple(torch.Tensor)`

`ParakeetRNNTOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [ParakeetForRNNT](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetForRNNT) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor`, *необязательный*) -- функция потерь RNN-T, возвращается при указании `labels`.
- **logits** (`torch.Tensor`) -- Совместные токены logits. Форма — `(batch, T, U+1, vocab)` для обучения или `(batch, 1, 1, vocab)` для одношагового вывода.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *optional*) -- Кэш LSTM декодера, содержащий скрытое состояние, состояние ячейки и последний вывод.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1034)

**Параметры:**

config ([ParakeetTDTConfig](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetTDTConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Parakeet Encoder с головой TDT (Token Duration Transducer).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/parakeet/modeling_parakeet.py#L1043)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, 1)`, *необязательный*) : Идентификаторы входных токенов декодера для одношагового вывода.

decoder_cache (`ParakeetRNNTDecoderCache`, *необязательный*) : Кэш LSTM декодера. Если передан и инициализирован, кэшированный `decoder_output` переиспользуется (например, при пропуске пустых токенов) вместо запуска декодера. Если передан `input_ids`, декодер выполняется, и кэш обновляется на месте.

use_decoder_cache (`bool`, *необязательный*) : Использовать ли кэш декодера. Если `True` и `decoder_cache` равно `None`, новый кэш создаётся автоматически во время прямого прохода.

encoder_outputs (`tuple(torch.Tensor)`, *необязательный*) : Предварительно вычисленные выходные данные энкодера (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Может быть кортежем или `ParakeetEncoderModelOutput`.

labels (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

**Возвращает:** `ParakeetRNNTOutput` или `tuple(torch.Tensor)`

`ParakeetRNNTOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [ParakeetForTDT](/docs/transformers/main/ru/model_doc/parakeet#transformers.ParakeetForTDT) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor`, *необязательный*) -- функция потерь RNN-T, возвращается при указании `labels`.
- **logits** (`torch.Tensor`) -- Совместные токены logits. Форма — `(batch, T, U+1, vocab)` для обучения или `(batch, 1, 1, vocab)` для одношагового вывода.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *optional*) -- Кэш LSTM декодера, содержащий скрытое состояние, состояние ячейки и последний вывод.

Пример:

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

