# Parakeet

## Resumen

Los modelos Parakeet, [introducidos por NVIDIA NeMo](https://developer.nvidia.com/blog/pushing-the-boundaries-of-speech-recognition-with-nemo-parakeet-asr-models/), son modelos que combinan un codificador [Fast Conformer](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/asr/models.html#fast-conformer) con un decodificador de clasificación temporal conexionista (CTC), transductor de red neuronal recurrente (RNNT) o transductor de token y duración (TDT) para el reconocimiento automático del habla.

**Arquitectura del modelo**

- **Fast Conformer Encoder**: una arquitectura Conformer de escalado lineal que procesa características de mel-espectrograma y reduce la longitud de la secuencia mediante subsampling. Esta es una versión más eficiente del Conformer Encoder presente en [FastSpeech2Conformer](./fastspeech2_conformer) (consulte [ParakeetEncoder](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetEncoder) para la implementación y los detalles del codificador).
- [**ParakeetForCTC**](#parakeetforctc-usage): un codificador Fast Conformer + un decodificador CTC
  - **Decodificador CTC**: Decodificador simple pero eficaz que consiste en:
    - Proyección de convolución 1D desde el tamaño oculto del codificador hasta el tamaño del vocabulario (para una compatibilidad óptima con NeMo).
    - Cálculo de la pérdida CTC para el entrenamiento.
    - Decodificación CTC codiciosa para la inferencia.
- [**ParakeetForRNNT**](#parakeetforrnnt-usage): un codificador Fast Conformer + un decodificador RNN-T (RNN Transducer)
  - **Decodificador RNN-T**: Transductor neuronal estándar:
    - La red de predicción LSTM mantiene el contexto del lenguaje a lo largo de las predicciones de tokens.
    - La red conjunta combina las salidas del codificador y el decodificador.
    - Decodificación transductor voraz para la inferencia: una emisión en blanco avanza el marco del codificador en uno, mientras que una emisión no en blanco permanece en el mismo marco.
- [**ParakeetForTDT**](#parakeetfortdt-usage): un codificador Fast Conformer + un decodificador TDT (Token Duration Transducer)
  - **Decodificador TDT**: Predice de forma conjunta los tokens y sus duraciones, lo que permite una decodificación eficiente:
    - La red de predicción LSTM mantiene el contexto del lenguaje a lo largo de las predicciones de tokens.
    - La red conjunta combina las salidas del codificador y el decodificador.
    - La cabeza de duración predice cuántos fotogramas omitir, lo que permite una inferencia rápida.

La implementación original se encuentra en [NVIDIA NeMo](https://github.com/NVIDIA/NeMo). Los puntos de control del modelo se encuentran bajo [la organización de NVIDIA](https://huggingface.co/nvidia/models?search=parakeet).

Este modelo fue aportado por [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) y [Hainan Xu](https://huggingface.co/hainanx).

## Uso

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

### Uso de ParakeetForRNNT

Parakeet RNN-T transcribe sin mayúsculas ni puntuación (como CTC), y el modelo también puede realizar la marca temporal de tokens.

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

A diferencia de TDT (que predice una duración por token), cada token de RNN-T se emite en un único marco del codificador, por lo que su inicio y final abarcan exactamente un marco.

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

### Uso de ParakeetForTDT

Las transcripciones de Parakeet TDT incluyen mayúsculas y minúsculas, y el modelo también puede realizar la marca de tiempo de tokens.

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

### Hacer que el modelo ruede

Parakeet admite la compilación de todo el grafo con captura de grafo (CUDA graphs en GPUs de NVIDIA, y el mecanismo equivalente en otros aceleradores) ¡Esta optimización es más eficaz cuando se conoce la longitud máxima de audio que se desea transcribir. La idea clave es usar formas de entrada estáticas para evitar la recompilación. Por ejemplo, si se sabe que el audio será inferior a 30 segundos, se puede usar el procesador para rellenar todas las entradas hasta 30 segundos, preparando características de entrada y máscaras de atención consistentes. ¡Vea el ejemplo a continuació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))
```

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

### Entrenamiento de RNN-T

> [!NOTE]
> Calcular la pérdida de RNN-T requiere [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()
```

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

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

Hereda todos los métodos de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend). Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos, excepto `_decode`, que se sobrescribe para adaptarlo a la decodificación CTC:
1. Agrupar tokens consecutivos
2. Filtrar el token en blanco

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/parakeet/feature_extraction_parakeet.py#L36)

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 80) : La dimensión de las características de las características extraídas.

sampling_rate (`int`, *opcional*, valor predeterminado 16000) : La frecuencia de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).

hop_length (`int`, *opcional*, valor predeterminado 160) : Longitud de las ventanas superpuestas para la STFT utilizada para obtener los coeficientes de Frecuencia Mel.

n_fft (`int`, *opcional*, valor predeterminado 512) : Tamaño de la transformada de Fourier.

win_length (`int`, *opcional*, valor predeterminado 400) : La longitud de la ventana para el cálculo de la STFT.

preemphasis (`float`, *opcional*, valor predeterminado 0.97) : Coeficiente de un filtro de preénfasis. 0.0 significa que no se aplica ningún filtro de preénfasis.

padding_value (`float`, *opcional*, valor predeterminado 0.0) : Valor de relleno utilizado para rellenar el audio. Debe corresponder a silencios.

Construye un extractor de características de Parakeet.

Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

Esta clase extrae características del banco de filtros mel de audio en bruto mediante una implementación personalizada de numpy de la `Short Time Fourier Transform`, que debe coincidir con el equivalente `torch.stft` de pytorch.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/parakeet/feature_extraction_parakeet.py#L122)

**Parámetros:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La secuencia o el lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. Debe ser audio de un solo canal, no estéreo, es decir, un solo valor flotante por paso de tiempo.

truncation (`bool`, *opcional*, valor predeterminado `True`) : Activa la truncación para recortar las secuencias de entrada más largas que *max_length* hasta *max_length*.

pad_to_multiple_of (`int`, *opcional*, valor predeterminado: None) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta), o en TPU, que se benefician de que las longitudes de secuencia sean un múltiplo de 128.

return_attention_mask (`bool`, *opcional*) : Si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del feature_extractor específico.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)    Para los modelos Parakeet, `attention_mask` siempre debe pasarse para la inferencia por lotes, para evitar errores sutiles.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'tf'`: Devuelve objetos `tf.constant` de TensorFlow. - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada `raw_speech`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos y permitir el pipeline de reconocimiento automático de voz.

padding_value (`float`, *opcional*, valor predeterminado 0.0) : El valor que se utiliza para rellenar los valores / vectores de relleno.

do_normalize (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe normalizar la entrada a media cero y varianza unitaria. La normalización puede ayudar a mejorar significativamente el rendimiento del modelo.

device (`str`, *opcional*, valor predeterminado `'cpu'`) : Especifica el dispositivo para el cálculo del espectrograma log-mel de las señales de audio en el método `_torch_extract_fbank_features`. (p. ej., "cpu", "cuda")

return_token_timestamps (`bool`, *opcional*, valor predeterminado `None`) : Obsoleto. Utilice `return_attention_mask` en su lugar, a partir del cual se puede inferir el número de fotogramas. Indica si se debe devolver o no el número de fotogramas de la entrada raw_speech. Estos num_frames pueden ser utilizados por el modelo para calcular marcas de tiempo a nivel de palabra.

Método principal para extraer características y preparar una o varias secuencias para el modelo. La implementación utiliza PyTorch para el cálculo de la STFT si está disponible; de lo contrario, se utiliza una implementación más lenta basada en NumPy.

## ParakeetProcessor[[transformers.ParakeetProcessor]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/parakeet/processing_parakeet.py#L29)

**Parámetros:**

feature_extractor (`feature_extractor_class`) : El extractor de características es una entrada obligatoria.

tokenizer (`tokenizer_class`): El tokenizador es una entrada obligatoria.

blank_token (`str`, *opcional*, valor predeterminado `"<blank>"`) : Token en blanco para la decodificación transductora.

decoder_type (`str`, *opcional*) : Modo de decodificación/emisión de marcas de tiempo. Valores posibles:  - `"ctc"`: Los tokens idénticos consecutivos se combinan en una sola emisión. - `"rnnt"`: Se conservan los tokens repetidos; cada token obtiene un intervalo de marca de tiempo de 1 cuadro. - `"tdt"`: Se conservan los tokens repetidos; el intervalo de cada token se basa en su duración predicha. La puntuación se adjunta al token anterior.  Si es `None` (puntos de control antiguos), el tipo de decodificador se infiere automáticamente por compatibilidad hacia atrás.

Construye un ParakeetProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

[ParakeetProcessor](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetProcessor) ofrece todas las funcionalidades de `feature_extractor_class` y `tokenizer_class`. Consulte `~feature_extractor_class` y `~tokenizer_class` para obtener más información.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/parakeet/processing_parakeet.py#L70)

**Parámetros:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestra del audio.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

sampling_rate (`int`, *opcional*) : La tasa de muestreo de la entrada de audio en Hz. Debe coincidir con la tasa de muestreo esperada por el extractor de características (por defecto, 16000 Hz). Si se proporciona, se validará contra la tasa de muestreo esperada por el procesador y se generará un error si no coinciden. Si no se proporciona, se emitirá una advertencia y se asumirá la tasa de muestreo predeterminada.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/parakeet/processing_parakeet.py#L128)

Pasa los argumentos a [decode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) y procesa los timestamps (si se proporcionan para TDT) de la misma manera que en la biblioteca 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)
```

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

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `24`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

intermediate_size (`int`, *opcional*, valor predeterminado `4096`) : Dimensión de las representaciones MLP.

hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

attention_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

convolution_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar sesgo en las convoluciones del módulo de convolución del conformer.

conv_kernel_size (`int`, *opcional*, valor predeterminado: 9) : El tamaño del kernel de las capas de convolución en el bloque Conformer.

subsampling_factor (`int`, *opcional*, valor predeterminado 8) : El factor por el cual se subsamplea la secuencia de entrada.

subsampling_conv_channels (`int`, *opcional*, valor predeterminado 256) : El número de canales en las capas de convolución de subsampling.

num_mel_bins (`int`, *opcional*, valor predeterminado 80) : Número de características mel.

subsampling_conv_kernel_size (`int`, *opcional*, valor predeterminado 3) : El tamaño del kernel de las capas de convolución de subsampling.

subsampling_conv_stride (`int`, *opcional*, valor predeterminado 2) : El paso de las capas de convolución de subsampling.

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción para todas las capas de dropout.

dropout_positions (`float`, *opcional*, valor predeterminado 0.0) : La proporción de dropout para las posiciones de la secuencia de entrada.

layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](see https://huggingface.co/papers/1909.11556) para obtener más detalles.

activation_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las activaciones dentro de la capa totalmente conectada.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención.

max_position_embeddings (`int`, *opcional*, valor predeterminado `5000`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

scale_input (`bool`, *opcional*, valor predeterminado `True`) : Si se debe escalar los embeddings de entrada.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un ParakeetModel. Se utiliza para instanciar un modelo Parakeet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `1025`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

ctc_loss_reduction (`str`, *opcional*, valor predeterminado `"mean"`) : Especifica la reducción que se aplicará a la salida de `torch.nn.CTCLoss`. Solo es relevante al entrenar una instancia de [ParakeetForCTC](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetForCTC).

ctc_zero_infinity (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben poner a cero las pérdidas infinitas y los gradientes asociados de `torch.nn.CTCLoss`. Las pérdidas infinitas ocurren principalmente cuando las entradas son demasiado cortas para alinearse con las dianas. Solo es relevante al entrenar una instancia de [ParakeetForCTC](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetForCTC).

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *opcional*) : El objeto de configuración o el diccionario del codificador.

pad_token_id (`int`, *opcional*, valor predeterminado `1024`) : Id de token utilizado para el relleno en el vocabulario.

Esta es la clase de configuración para almacenar la configuración de un ParakeetModel. Se utiliza para instanciar un modelo Parakeet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/parakeet-ctc-1.1b](https://huggingface.co/nvidia/parakeet-ctc-1.1b)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

vocab_size (`int`, *opcional*, valor predeterminado `8193`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

decoder_hidden_size (`int`, *opcional*, valor predeterminado 640) : Tamaño oculto de la red de predicción LSTM y la red conjunta.

num_decoder_layers (`int`, *opcional*, valor predeterminado 2) : Número de capas LSTM en la red de predicción.

hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_symbols_per_step (`int`, *opcional*, valor predeterminado 10) : Número máximo de símbolos que se emiten por paso de tiempo del codificador durante la decodificación codiciosa.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *opcional*) : El objeto de configuración o el diccionario del codificador.

pad_token_id (`int`, *opcional*, valor predeterminado `2`) : Id del token utilizado para el relleno en el vocabulario.

blank_token_id (`int`, *opcional*, valor predeterminado 8192) : ID del token en blanco. Difiere de `pad_token_id` para RNN-T.

Esta es la clase de configuración para almacenar la configuración de un ParakeetModel. Se utiliza para instanciar un modelo Parakeet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/parakeet-rnnt-0.6b](https://huggingface.co/nvidia/parakeet-rnnt-0.6b)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

vocab_size (`int`, *opcional*, valor predeterminado `8193`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

decoder_hidden_size (`int`, *opcional*, valor predeterminado 640) : Tamaño oculto de la red de predicción LSTM y la red conjunta.

num_decoder_layers (`int`, *opcional*, valor predeterminado 2) : Número de capas LSTM en la red de predicción.

hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_symbols_per_step (`int`, *opcional*, valor predeterminado 10) : Número máximo de símbolos que se emiten por paso de tiempo del codificador durante la decodificación codiciosa.

encoder_config (`Union[dict, ParakeetEncoderConfig]`, *opcional*) : El objeto de configuración o el diccionario del codificador.

pad_token_id (`int`, *opcional*, valor predeterminado `2`) : Id del token utilizado para el relleno en el vocabulario.

blank_token_id (`int`, *opcional*, valor predeterminado 8192) : ID del token en blanco. Difiere de `pad_token_id` para TDT.

durations (`list[int]`, *opcional*, valor predeterminado `[0, 1, 2, 3, 4]`) : Valores de duración de los tokens que pueden predecirse. Cada valor representa cuántos fotogramas abarca un token o una emisión en blanco.

Esta es la clase de configuración para almacenar la configuración de un ParakeetModel. Se utiliza para instanciar un modelo Parakeet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/parakeet-tdt-0.6b-v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

config ([ParakeetEncoderConfig](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetEncoderConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Parakeet Encoder, basado en la [arquitectura Fast Conformer](https://huggingface.co/papers/2305.05084).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para obtener más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

output_attention_mask (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver la máscara de atención de salida. Solo es efectivo cuando se proporciona `attention_mask`.

**Devuelve:** [BaseModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

El método forward de [ParakeetEncoder](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetEncoder) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

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

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

**Parámetros:**

config ([ParakeetCTCConfig](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetCTCConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Parakeet Encoder con una cabeza de Connectionist Temporal Classification (CTC).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para obtener más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

**Devuelve:** [CausalLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutput) o `tuple(torch.Tensor)`

Un [CausalLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

El método forward de [ParakeetForCTC](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetForCTC) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

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

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

compile_config ([CompileConfig](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.CompileConfig), *opcional*): Si se proporciona, `torch.compile` se aplicará a las llamadas forward en el bucle de decodificación.

Ejemplo:

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

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

**Parámetros:**

config ([ParakeetRNNTConfig](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetRNNTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Parakeet Encoder con una cabeza RNN-T (RNN Transducer).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*) : ids de tokens de entrada del decodificador para inferencia de un solo paso.

decoder_cache (`ParakeetRNNTDecoderCache`, *opcional*) : Caché del LSTM del decodificador. Cuando se proporciona e inicializa, se reutiliza el `decoder_output` en caché (p. ej., durante el salto de espacios en blanco) en lugar de ejecutar el decodificador. Cuando se proporciona `input_ids`, se ejecuta el decodificador y la caché se actualiza in situ.

use_decoder_cache (`bool`, *opcional*) : Indica si se debe usar una caché del decodificador. Cuando `True` y `decoder_cache` es `None`, se crea automáticamente una nueva caché durante la pasada hacia adelante.

encoder_outputs (`tuple(torch.Tensor)`, *opcional*) : Salidas del codificador precalculadas (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Puede ser una tupla o `ParakeetEncoderModelOutput`.

labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

**Devuelve:** `ParakeetRNNTOutput` o `tuple(torch.Tensor)`

Un `ParakeetRNNTOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

El método forward de [ParakeetForRNNT](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetForRNNT) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor`, *opcional*) -- Pérdida de RNN-T, devuelta cuando se proporcionan `labels`.
- **logits** (`torch.Tensor`) -- Logits conjuntos de tokens. La forma es `(batch, T, U+1, vocab)` para entrenamiento o `(batch, 1, 1, vocab)` para inferencia de un solo paso.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *opcional*) -- Caché del LSTM del decodificador que contiene el estado oculto, el estado de la celda y la última salida.

Ejemplo:

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

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

**Parámetros:**

config ([ParakeetTDTConfig](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetTDTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Parakeet Encoder con una cabeza TDT (Token Duration Transducer).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*) : ids de tokens de entrada del decodificador para inferencia de un solo paso.

decoder_cache (`ParakeetRNNTDecoderCache`, *opcional*) : Caché del LSTM del decodificador. Cuando se proporciona e inicializa, se reutiliza el `decoder_output` en caché (p. ej., durante el salto de espacios en blanco) en lugar de ejecutar el decodificador. Cuando se proporciona `input_ids`, se ejecuta el decodificador y la caché se actualiza in situ.

use_decoder_cache (`bool`, *opcional*) : Indica si se debe usar una caché del decodificador. Cuando `True` y `decoder_cache` es `None`, se crea automáticamente una nueva caché durante la pasada hacia adelante.

encoder_outputs (`tuple(torch.Tensor)`, *opcional*) : Salidas del codificador precalculadas (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Puede ser una tupla o `ParakeetEncoderModelOutput`.

labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

**Devuelve:** `ParakeetRNNTOutput` o `tuple(torch.Tensor)`

Un `ParakeetRNNTOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

El método forward de [ParakeetForTDT](/docs/transformers/v5.23.0/es/model_doc/parakeet#transformers.ParakeetForTDT) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor`, *opcional*) -- Pérdida de RNN-T, devuelta cuando se proporcionan `labels`.
- **logits** (`torch.Tensor`) -- Logits conjuntos de tokens. La forma es `(batch, T, U+1, vocab)` para entrenamiento o `(batch, 1, 1, vocab)` para inferencia de un solo paso.
- **decoder_cache** (`ParakeetRNNTDecoderCache`, *opcional*) -- Caché del LSTM del decodificador que contiene el estado oculto, el estado de la celda y la última salida.

Ejemplo:

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

