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.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 25/09/2025.

SDPA

Parakeet

Visão geral

Os modelos Parakeet, introduzidos pelo NVIDIA NeMo, são modelos que combinam um codificador Fast Conformer com um decodificador de classificação temporal conexionista (CTC), transdutor de rede neural recorrente (RNNT) ou transdutor de token e duração (TDT) para reconhecimento automático de fala.

Arquitetura do Modelo

  • Fast Conformer Encoder: uma arquitetura Conformer com escalabilidade linear que processa recursos de mel-espectrograma e reduz o comprimento da sequência por meio de subsampling. Esta é uma versão mais eficiente do Conformer Encoder encontrado em FastSpeech2Conformer (consulte ParakeetEncoder para a implementação e os detalhes do encoder).
  • ParakeetForCTC: um Fast Conformer Encoder + um decodificador CTC
    • CTC Decoder: Decodificador simples, porém eficaz, composto por:
      • Projeção de convolução 1D do tamanho oculto do codificador para o tamanho do vocabulário (para compatibilidade ideal com o NeMo).
      • Cálculo da perda CTC para treinamento.
      • Decodificação CTC gulosa para inferência.
  • ParakeetForRNNT: um encoder Fast Conformer + um decoder RNN-T (RNN Transducer)
    • RNN-T Decoder: Transdutor neural padrão:
      • A rede de predição LSTM mantém o contexto da linguagem entre as predições de tokens.
      • A rede conjunta combina as saídas do codificador e do decodificador.
      • Decodificação por transdutor guloso para inferência: uma emissão de vazio avança o quadro do codificador em um, enquanto uma emissão não vazia permanece no mesmo quadro.
  • ParakeetForTDT: um Fast Conformer Encoder + um decodificador TDT (Token Duration Transducer)
    • TDT Decoder: Prevê simultaneamente os tokens e suas durações, permitindo uma decodificação eficiente:
      • A rede de predição LSTM mantém o contexto da linguagem entre as predições de tokens.
      • A rede conjunta combina as saídas do codificador e do decodificador.
      • A cabeça de duração prevê quantos quadros pular, permitindo inferência rápida.

A implementação original pode ser encontrada no NVIDIA NeMo. Os checkpoints dos modelos estão disponíveis sob a organização da NVIDIA.

Este modelo foi contribuído por Nithin Rao Koluguri, Eustache Le Bihan, Eric Bezzam, Maksym Lypivskyi e Hainan Xu.

Uso

Uso do 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
Carimbo de data e hora

O Parakeet RNN-T transcreve sem maiúsculas ou pontuação (como o CTC) e o modelo também pode realizar a marcação de tempo dos 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 do ParakeetForTDT

Pipeline
AutoModel
Carimbo de data e hora

Os transcritos do Parakeet TDT incluem capitalização, e o modelo também pode realizar a marcação de timestamps dos 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.'}

Fazendo o modelo rodar a todo vapor

Parakeet suporta compilação de grafo completo com captura de grafo (CUDA graphs em GPUs NVIDIA, e o mecanismo equivalente em outros aceleradores)! Essa otimização é mais eficaz quando você conhece o comprimento máximo de áudio que deseja transcrever. A ideia central é usar formas de entrada estáticas para evitar recompilação. Por exemplo, se você sabe que seu áudio terá menos de 30 segundos, pode usar o processador para preencher todas as entradas até 30 segundos, preparando recursos de entrada e máscaras de atenção consistentes. Veja o exemplo abaixo!

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

Treinamento 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()

Treinamento de RNN-T

O cálculo da perda RNN-T requer 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()

Treinamento 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

classe transformers.ParakeetTokenizer

< >

( *args**kwargs )

Herdita todos os métodos de PreTrainedTokenizerFast. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos, exceto _decode, que é sobrescrito para adaptá-lo à decodificação CTC:

  1. Agrupar tokens consecutivos
  2. Filtre o token em branco

ParakeetFeatureExtractor

classe 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, padrão 80) — A dimensão dos recursos das características extraídas.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
  • hop_length (int, opcional, padrão 160) — Comprimento das janelas sobrepostas para a STFT usada para obter os coeficientes de Frequência Mel.
  • n_fft (int, opcional, padrão 512) — Tamanho da transformada de Fourier.
  • win_length (int, opcional, padrão 400) — O comprimento da janela para o cálculo da STFT.
  • preemphasis (float, opcional, padrão 0.97) — Coeficiente de um filtro de pré-ênfase. 0.0 significa que não há filtro de pré-ênfase.
  • padding_value (float, opcional, padrão 0.0) — Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.

Constrói um extrator de recursos Parakeet.

Este extrator de características herda de SequenceFeatureExtractor, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

Esta classe extrai recursos de banco de filtros mel a partir de fala bruta usando uma implementação customizada em numpy da Short Time Fourier Transform, que deve corresponder ao equivalente torch.stft do 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]]) — A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Deve ser áudio mono, não estéreo, ou seja, um único float por timestep.
  • truncation (bool, opcional, padrão True) — Ativa a truncagem para cortar sequências de entrada com comprimento maior que max_length para max_length.
  • pad_to_multiple_of (int, opcional, padrão None) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido.

    Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação >= 7.5 (Volta), ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128.

  • return_attention_mask (bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão específico do feature_extractor.

    O que são máscaras de atenção?

    Para os modelos Parakeet, attention_mask deve sempre ser passado em inferência em lote, para evitar bugs sutis.

  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'tf': Retorna objetos tf.constant do TensorFlow.
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do Numpy.
  • sampling_rate (int, opcional) — A taxa de amostragem na qual a entrada raw_speech foi amostrada. É fortemente recomendável passar sampling_rate na chamada de forward para evitar erros silenciosos e permitir o pipeline de reconhecimento automático de fala.
  • padding_value (float, opcional, padrão 0.0) — O valor usado para preencher os valores/vetores de padding.
  • do_normalize (bool, opcional, padrão False) — Indica se a entrada deve ser normalizada com média zero e variância unitária. A normalização pode ajudar a melhorar significativamente o desempenho do modelo.
  • device (str, opcional, padrão 'cpu') — Especifica o dispositivo para o cálculo do espectrograma log-mel dos sinais de áudio no método _torch_extract_fbank_features. (ex.: “cpu”, “cuda”)
  • return_token_timestamps (bool, opcional, padrão None) — Descontinuado. Use return_attention_mask em vez disso, a partir do qual o número de quadros pode ser inferido.

    Se deve ou não retornar o número de quadros do raw_speech de entrada. Esses num_frames podem ser usados pelo modelo para calcular timestamps no nível de palavra.

Método principal para extrair características de uma ou várias sequências e prepará-las para o modelo. A implementação usa PyTorch para o cálculo do STFT, se disponível; caso contrário, utiliza uma implementação mais lenta baseada em NumPy.

ParakeetProcessor

classe transformers.ParakeetProcessor

< >

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

Parâmetros

  • feature_extractor (feature_extractor_class) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (tokenizer_class) — O tokenizer é uma entrada obrigatória.
  • blank_token (str, opcional, padrão "<blank>") — Token em branco para decodificação transdutora.
  • decoder_type (str, opcional) — Modo de decodificação/emissão de timestamps. Valores possíveis:
    • "ctc": Tokens idênticos consecutivos são mesclados em uma única emissão.
    • "rnnt": Tokens repetidos são mantidos; cada token recebe uma faixa de timestamp de 1 quadro.
    • "tdt": Tokens repetidos são mantidos; cada intervalo de tokens é baseado em sua duração prevista. A pontuação é anexada ao token anterior.

    Se None (checkpoints mais antigos), o tipo de decodificador é inferido automaticamente para compatibilidade reversa.

Constrói um ParakeetProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

ParakeetProcessor oferece todas as funcionalidades de feature_extractor_class e tokenizer_class. Consulte ~feature_extractor_class e ~tokenizer_class para mais informações.

__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]]) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostragem do áudio.
  • text (Union[str, list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • sampling_rate (int, opcional) — A taxa de amostragem do áudio de entrada em Hz. Deve corresponder à taxa de amostragem esperada pelo extrator de recursos (padrão: 16000 Hz). Se fornecida, será validada em relação à taxa de amostragem esperada pelo processador, e um erro será lançado caso não correspondam. Se não for fornecida, um aviso será emitido e a taxa de amostragem padrão será assumida.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

decode

< >

( *argsdurations = None**kwargs )

Encaminhe os argumentos para decode() e faça o pós-processamento dos timestamps (se fornecidos para TDT) da mesma forma que na biblioteca NeMo.

ParakeetEncoderConfig

classe 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, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • attention_bias (bool, opcional, padrão True) — Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • convolution_bias (bool, opcional, padrão True) — Indica se deve ser usado viés nas convoluções do módulo de convolução do conformer.
  • conv_kernel_size (int, opcional, padrão 9) — O tamanho do kernel das camadas de convolução no bloco Conformer.
  • subsampling_factor (int, opcional, padrão 8) — O fator pelo qual a sequência de entrada é subsampleada.
  • subsampling_conv_channels (int, opcional, padrão 256) — O número de canais nas camadas de convolução de subsampling.
  • num_mel_bins (int, opcional, padrão 80) — Número de recursos mel.
  • subsampling_conv_kernel_size (int, opcional, padrão 3) — O tamanho do kernel das camadas de convolução de subsampling.
  • subsampling_conv_stride (int, opcional, padrão 2) — O stride das camadas de convolução de subsampling.
  • dropout (Union[float, int], opcional, padrão 0.1) — A proporção para todas as camadas de dropout.
  • dropout_positions (float, opcional, padrão 0.0) — A taxa de dropout para as posições na sequência de entrada.
  • layerdrop (Union[float, int], opcional, padrão 0.1) — A probabilidade do LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • activation_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
  • attention_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as probabilidades de atenção.
  • max_position_embeddings (int, opcional, padrão 5000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • scale_input (bool, opcional, padrão True) — Se as embeddings de entrada devem ser escalonadas.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um ParakeetModel. Ela é usada para instanciar um modelo Parakeet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/parakeet-ctc-1.1b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe 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, padrão 1025) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • ctc_loss_reduction (str, opcional, padrão "mean") — Especifica a redução a ser aplicada à saída de torch.nn.CTCLoss. Relevante apenas ao treinar uma instância de ParakeetForCTC.
  • ctc_zero_infinity (bool, opcional, padrão True) — Se deve zerar perdas infinitas e os gradientes associados de torch.nn.CTCLoss. Perdas infinitas ocorrem principalmente quando as entradas são curtas demais para serem alinhadas aos alvos. Relevante apenas ao treinar uma instância de ParakeetForCTC.
  • encoder_config (Union[dict, ParakeetEncoderConfig], opcional) — O objeto de configuração ou dicionário do codificador.
  • pad_token_id (int, opcional, padrão 1024) — ID do token usado para preenchimento no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um ParakeetModel. Ela é usada para instanciar um modelo Parakeet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/parakeet-ctc-1.1b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe 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, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • vocab_size (int, opcional, padrão 8193) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • decoder_hidden_size (int, opcional, padrão 640) — Tamanho oculto da rede de previsão LSTM e da rede conjunta.
  • num_decoder_layers (int, opcional, padrão 2) — Número de camadas LSTM na rede de predição.
  • hidden_act (str, opcional, padrão relu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_symbols_per_step (int, opcional, padrão 10) — Número máximo de símbolos a serem emitidos por passo de tempo do codificador durante a decodificação gulosa.
  • encoder_config (Union[dict, ParakeetEncoderConfig], opcional) — O objeto de configuração ou dicionário do codificador.
  • pad_token_id (int, opcional, padrão 2) — ID do token usado para preenchimento no vocabulário.
  • blank_token_id (int, opcional, padrão 8192) — ID do token em branco. Diferente de pad_token_id para RNN-T.

Esta é a classe de configuração para armazenar a configuração de um ParakeetModel. Ela é usada para instanciar um modelo Parakeet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/parakeet-rnnt-0.6b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe 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, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • vocab_size (int, opcional, padrão 8193) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • decoder_hidden_size (int, opcional, padrão 640) — Tamanho oculto da rede de previsão LSTM e da rede conjunta.
  • num_decoder_layers (int, opcional, padrão 2) — Número de camadas LSTM na rede de predição.
  • hidden_act (str, opcional, padrão relu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_symbols_per_step (int, opcional, padrão 10) — Número máximo de símbolos a serem emitidos por passo de tempo do codificador durante a decodificação gulosa.
  • encoder_config (Union[dict, ParakeetEncoderConfig], opcional) — O objeto de configuração ou dicionário do codificador.
  • pad_token_id (int, opcional, padrão 2) — ID do token usado para preenchimento no vocabulário.
  • blank_token_id (int, opcional, padrão 8192) — ID do token em branco. Diferente de pad_token_id para TDT.
  • durations (list[int], opcional, padrão [0, 1, 2, 3, 4]) — Valores de duração dos tokens que podem ser previstos. Cada valor representa quantos quadros um token ou uma emissão de blank abrange.

Esta é a classe de configuração para armazenar a configuração de um ParakeetModel. Ela é usada para instanciar um modelo Parakeet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/parakeet-tdt-0.6b-v3

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe transformers.ParakeetEncoder

< >

( config: ParakeetEncoderConfig )

Parâmetros

  • config (ParakeetEncoderConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Parakeet Encoder, baseado na arquitetura Fast Conformer.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • output_attention_mask (bool, opcional, padrão True) — Indica se a máscara de atenção de saída deve ser retornada. Efetivo apenas quando attention_mask é fornecida.

Retorna

BaseModelOutput ou tuple(torch.Tensor)

Um BaseModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (None) e das entradas.

O método forward do ParakeetEncoder sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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

classe transformers.ParakeetForCTC

< >

( config: ParakeetCTCConfig )

Parâmetros

  • config (ParakeetCTCConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Parakeet Encoder com uma cabeça de Classificação Temporal Conectiva (CTC).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna

CausalLMOutput ou tuple(torch.Tensor)

Um CausalLMOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (None) e das entradas.

O método forward de ParakeetForCTC substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

>>> 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): Se fornecido, torch.compile será aplicado às chamadas de forward no loop de decodificação.

Exemplo:

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

classe transformers.ParakeetForRNNT

< >

( config: ParakeetRNNTConfig )

Parâmetros

  • config (ParakeetRNNTConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Parakeet Encoder com uma cabeça RNN-T (RNN Transducer).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, 1), opcional) — IDs de tokens de entrada do decodificador para inferência em etapa única.
  • decoder_cache (ParakeetRNNTDecoderCache, opcional) — Cache do LSTM do decoder. Quando fornecido e inicializado, o decoder_output em cache é reutilizado (por exemplo, durante o blank-skipping) em vez de executar o decoder. Quando input_ids é fornecido, o decoder é executado e o cache é atualizado in-place.
  • use_decoder_cache (bool, opcional) — Se deve usar um cache do decoder. Quando True e decoder_cache é None, um novo cache é criado automaticamente durante a forward pass.
  • encoder_outputs (tuple(torch.Tensor), opcional) — Saídas pré-computadas do codificador (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Pode ser uma tupla ou ParakeetEncoderModelOutput.
  • labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna

ParakeetRNNTOutput ou tuple(torch.Tensor)

Uma ParakeetRNNTOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo vários elementos dependendo da configuração (None) e das entradas.

O método forward de ParakeetForRNNT substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor, opcional) — Perda RNN-T, retornada quando labels são fornecidas.
  • logits (torch.Tensor) — Logits conjuntos dos tokens. A forma é (batch, T, U+1, vocab) para treinamento ou (batch, 1, 1, vocab) para inferência de etapa única.
  • decoder_cache (ParakeetRNNTDecoderCache, opcional) — Cache do LSTM do decodificador contendo estado oculto, estado da célula e última saída.

Exemplo:

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

classe transformers.ParakeetForTDT

< >

( config: ParakeetTDTConfig )

Parâmetros

  • config (ParakeetTDTConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Parakeet Encoder com uma cabeça TDT (Token Duration Transducer).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, 1), opcional) — IDs de tokens de entrada do decodificador para inferência em etapa única.
  • decoder_cache (ParakeetRNNTDecoderCache, opcional) — Cache do LSTM do decoder. Quando fornecido e inicializado, o decoder_output em cache é reutilizado (por exemplo, durante o blank-skipping) em vez de executar o decoder. Quando input_ids é fornecido, o decoder é executado e o cache é atualizado in-place.
  • use_decoder_cache (bool, opcional) — Se deve usar um cache do decoder. Quando True e decoder_cache é None, um novo cache é criado automaticamente durante a forward pass.
  • encoder_outputs (tuple(torch.Tensor), opcional) — Saídas pré-computadas do codificador (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask). Pode ser uma tupla ou ParakeetEncoderModelOutput.
  • labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna

ParakeetRNNTOutput ou tuple(torch.Tensor)

Um ParakeetRNNTOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False), contendo vários elementos dependendo da configuração (None) e das entradas.

O método forward de ParakeetForTDT substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor, opcional) — Perda RNN-T, retornada quando labels são fornecidas.
  • logits (torch.Tensor) — Logits conjuntos dos tokens. A forma é (batch, T, U+1, vocab) para treinamento ou (batch, 1, 1, vocab) para inferência de etapa única.
  • decoder_cache (ParakeetRNNTDecoderCache, opcional) — Cache do LSTM do decodificador contendo estado oculto, estado da célula e última saída.

Exemplo:

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