Hugging Face's logo

Transformers documentation

Parakeet

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo fue aportado a Hugging Face Transformers el 2025-09-25.

SDPA

Parakeet

Resumen

Los modelos Parakeet, introducidos por NVIDIA NeMo, son modelos que combinan un codificador 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 (consulte ParakeetEncoder para la implementación y los detalles del codificador).
  • ParakeetForCTC: un codificador Fast Conformer + un decodificador CTC
    • CTC Decoder: 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: un codificador Fast Conformer + un decodificador RNN-T (RNN Transducer)
    • RNN-T Decoder: 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: un codificador Fast Conformer + un decodificador TDT (Token Duration Transducer)
    • TDT Decoder: 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. Los puntos de control del modelo se encuentran bajo la organización de NVIDIA.

Este modelo fue aportado por Nithin Rao Koluguri, Eustache Le Bihan, Eric Bezzam, Maksym Lypivskyi y Hainan Xu.

Uso

Uso de ParakeetForCTC

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

Uso de ParakeetForRNNT

Pipeline
AutoModel
Marcado de tiempo

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

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

Uso de ParakeetForTDT

Pipeline
AutoModel
Marcado de tiempo

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

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

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!

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

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

Calcular la pérdida de RNN-T requiere torchaudio (pip install torchaudio).

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision,  device_map="auto")
model.train()

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

Entrenamiento TDT

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, device_map="auto")
model.train()

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

ParakeetTokenizer

clase transformers.ParakeetTokenizer

< >

( *args**kwargs )

Hereda todos los métodos de PreTrainedTokenizerFast. Los usuarios deben consultar esta superclase para obtener más información sobre esos 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

clase transformers.ParakeetFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0**kwargs )

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 tasa 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, 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 de 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.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'longest'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'return_token_timestamps: bool | None = None**kwargs )

Parámetros

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La secuencia o lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores float, una lista de arrays de numpy o una lista de listas de valores float. Debe ser audio de canal mono, no estéreo, es decir, un solo float 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, predeterminado a 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 TPUs, 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?

    Para los modelos Parakeet, attention_mask siempre debe pasarse en la inferencia por lotes para evitar errores sutiles.

  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista 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 Numpy np.ndarray.
  • 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 con media cero y varianza unitaria. La normalización puede ayudar a mejorar significativamente el rendimiento del modelo.
  • device (str, opcional, por defecto '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, por defecto None) — Obsoleto. Usa return_attention_mask en su lugar, a partir del cual se puede inferir el número de fotogramas.

    Si se debe o no devolver 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, utiliza una implementación más lenta basada en NumPy.

ParakeetProcessor

clase transformers.ParakeetProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'decoder_type = None )

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 del transductor.
  • 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 rango de marcas de tiempo de 1 cuadro.
    • "tdt": Se conservan los tokens repetidos; cada tramo de tokens 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 para la compatibilidad hacia atrás.

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

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.

__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 = Nonesampling_rate: int | None = None**kwargs: *<class 'transformers.models.parakeet.processing_parakeet.ParakeetProcessorKwargs'> )

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 la muestra del audio.
  • text (Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • sampling_rate (int, opcional) — La tasa de muestreo del audio de entrada 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_tensors (str o 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, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

decode

< >

( *argsdurations = None**kwargs )

Pasa los argumentos a decode() y procesa los timestamps (si se proporcionan para TDT) de la misma manera que en la biblioteca NeMo.

ParakeetEncoderConfig

clase transformers.ParakeetEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02 )

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 Transformer.
  • intermediate_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones del 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) — Si se usa 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 realiza el submuestreo de 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](ver https://huggingface.co/papers/1909.11556) para 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 deben escalar los embeddings de entrada.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.ParakeetCTCConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 1025ctc_loss_reduction: str = 'mean'ctc_zero_infinity: bool = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int | None = 1024 )

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 debe aplicar a la salida de torch.nn.CTCLoss. Solo es relevante al entrenar una instancia de ParakeetForCTC.
  • ctc_zero_infinity (bool, opcional, valor predeterminado True) — 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 los objetivos. Solo es relevante al entrenar una instancia de 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 del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.ParakeetRNNTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 8193decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 2blank_token_id: int = 8192 )

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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.ParakeetTDTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 8193decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 2blank_token_id: int = 8192durations: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4) )

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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.ParakeetEncoder

< >

( config: ParakeetEncoderConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

El modelo Parakeet Encoder, basado en la arquitectura Fast Conformer.

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attention_mask: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

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 utilizando 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • output_attention_mask (bool, opcional, valor predeterminado True) — Si se debe devolver la máscara de atención de salida. Solo es efectivo cuando se proporciona attention_mask.

Devuelve

BaseModelOutput o tuple(torch.Tensor)

Un 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 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 pre y postprocesamiento, 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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:

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

clase transformers.ParakeetForCTC

< >

( config: ParakeetCTCConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

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

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)

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 utilizando 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].

Devuelve

CausalLMOutput o tuple(torch.Tensor)

Un 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 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 pre y postprocesamiento, 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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:

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

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonereturn_dict_in_generate: bool = Falsecompile_config: transformers.generation.configuration_utils.CompileConfig | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

compile_config (CompileConfig, opcional): Si se proporciona, torch.compile se aplicará a las llamadas forward en el bucle de decodificación.

Ejemplo:

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

clase transformers.ParakeetForRNNT

< >

( config: ParakeetRNNTConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

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

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput or tuple(torch.Tensor)

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 utilizando 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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. Si se proporciona y está inicializada, se reutiliza el decoder_output en caché (p. ej., durante el salto de blancos) en lugar de ejecutar el decodificador. Si se proporciona input_ids, se ejecuta el decodificador y la caché se actualiza in situ.
  • use_decoder_cache (bool, opcional) — 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 (enmascarados); 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 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 pre y postprocesamiento, 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 de tokens conjuntos. 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:

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

clase transformers.ParakeetForTDT

< >

( config: ParakeetTDTConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

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

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput or tuple(torch.Tensor)

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 utilizando 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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. Si se proporciona y está inicializada, se reutiliza el decoder_output en caché (p. ej., durante el salto de blancos) en lugar de ejecutar el decodificador. Si se proporciona input_ids, se ejecuta el decodificador y la caché se actualiza in situ.
  • use_decoder_cache (bool, opcional) — 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 (enmascarados); 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 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 pre y postprocesamiento, 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 de tokens conjuntos. 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:

>>> 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)
Update on GitHub

←NeuCodec PE Audio→