Hugging Face's logo

Transformers documentation

LASR

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 publicado em HF papers em 2020-05-16 e contribuído para Hugging Face Transformers em 2025-12-05.

SDPA

LASR

Visão geral

LASR é a arquitetura por trás do MedASR, um modelo de fala para texto do Google Health AI pré-treinado para ditado médico. Ele é baseado na arquitetura Conformer e projetado como ponto de partida para desenvolvedores que criam ferramentas de ditado com terminologia médica, como ditado de radiologia. O MedASR apresenta bom desempenho em áudio médico, mas pode ter dificuldades com termos fora de seus dados de treinamento, como nomes de medicamentos não padrão ou referências temporais (datas, horários ou durações).

Uso

Uso básico

Pipeline
AutoModel
from transformers import pipeline


pipe = pipeline("automatic-speech-recognition", model="google/medasr")
out = pipe("path/to/audio.mp3")
print(out)

Treinamento

O exemplo abaixo prepara um lote de áudio e texto, o passa pelo modelo LASR/MedASR e calcula a perda de treinamento.

from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor


# Load processor and model
processor = AutoProcessor.from_pretrained("google/medasr")
model = AutoModelForCTC.from_pretrained("google/medasr", device_map="auto")

# Load a small example dataset and prepare batch
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]]
text_samples = [el for el in ds["text"][:5]]

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

outputs = model(**inputs)
outputs.loss.backward()

LasrTokenizer

classe transformers.LasrTokenizer

< >

( eos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'_spm_precompiled_charsmap = Noneextra_ids = 100additional_special_tokens = Nonevocab = Nonevocab_file = None**kwargs )

Parâmetros

  • vocab_file (str, opcional) — arquivo SentencePiece (geralmente com a extensão .spm) que contém o vocabulário necessário para instanciar um tokenizador.
  • eos_token (str, opcional, padrão é "</s>") — O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token usado para o fim da sequência. O token utilizado é o sep_token.

    Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o sep_token.

  • unk_token (str, opcional, padrão "<unk>") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
  • pad_token (str, opcional, padrão "<pad>") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
  • extra_ids (int, opcional, padrão 100) — Adiciona um número de ids extras à vocabulária para uso como sentinels. Esses tokens são acessíveis como “id{%d}>”, onde “{%d}” é um número entre 0 e extra_ids-1. Esses tokens podem ser obtidos chamando o método get_sentinel_tokens e os ids dos tokens podem ser obtidos chamando o método get_sentinel_token_ids
  • additional_special_tokens (list[str], opcional) — Tokens especiais adicionais usados pelo tokenizer.
  • vocab (str, dict ou list, opcional) — Dicionário de vocabulário personalizado. Se não for fornecido, um vocabulário mínimo é criado usando os tokens especiais.

Construa um tokenizador LASR (baseado na biblioteca tokenizers do HuggingFace). Baseado em Unigram.

Este tokenizador herda de TokenizersBackend, 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.

get_sentinel_token_ids

< >

( )

Obtenha os IDs de tokens para tokens sentinel.

get_sentinel_tokens

< >

( )

Obtenha a lista de tokens sentinel (tokens extra_id) de additional_special_tokens.

LasrFeatureExtractor

classe transformers.LasrFeatureExtractor

< >

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

Parâmetros

  • feature_size (int, opcional, padrão 128) — 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.
  • 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 LASR.

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.

LasrProcessor

classe transformers.LasrProcessor

< >

( feature_extractortokenizer )

Parâmetros

  • feature_extractor (feature_extractor_class) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (tokenizer_class) — O tokenizer é uma entrada obrigatória.

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

LasrProcessor 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.lasr.processing_lasr.LasrProcessorKwargs'> )

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.

batch_decode

< >

( *args**kwargs )

Este método encaminha todos os seus argumentos para o batch_decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

decode

< >

( *args**kwargs )

Este método encaminha todos os seus argumentos para o decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

LasrEncoderConfig

classe transformers.LasrEncoderConfig

< >

( 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 = 512num_hidden_layers: int = 17num_attention_heads: int = 8intermediate_size: int = 2048hidden_act: str = 'silu'attention_bias: bool = Falseconvolution_bias: bool = Falseconv_kernel_size: int = 32subsampling_conv_channels: int = 256num_mel_bins: int = 128subsampling_conv_kernel_size: int = 5subsampling_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 = 10000initializer_range: float = 0.02layer_norm_eps: float = 1e-06feed_forward_residual_weights: list[float] | tuple[float, ...] = (1.5, 0.5)conv_residual_weights: list[float] | tuple[float, ...] = (2.0, 1.0)batch_norm_momentum: float = 0.01rope_parameters: dict | None = None )

Parâmetros

  • hidden_size (int, opcional, padrão 512) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 17) — 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 2048) — 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 False) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • convolution_bias (bool, opcional, padrão False) — 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 32) — O tamanho do kernel das camadas de convolução no bloco Conformer.
  • 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 128) — Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor utilizado na classe AutoFeatureExtractor.
  • subsampling_conv_kernel_size (int, opcional, padrão 5) — 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 10000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • layer_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização de camada.
  • feed_forward_residual_weights (tuple[float, float], opcional, padrão [1.5, 0.5]) — Os pesos residuais para as camadas feed forward.
  • conv_residual_weights (tuple[float, float], opcional, padrão [2.0, 1.0]) — Os pesos residuais para as camadas de convolução.
  • batch_norm_momentum (float, opcional, padrão 0.01) — O momentum para as camadas de normalização de lote
  • rope_parameters (dict, opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.

Esta é a classe de configuração para armazenar a configuração de um LasrModel. Ela é usada para instanciar um modelo Lasr 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 google/medasr

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 LasrEncoderModel, LasrEncoderConfig

>>> # Initializing a `LasrEncoder` configuration
>>> configuration = LasrEncoderConfig()

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

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

Esta classe de configuração é baseada na arquitetura LasrEncoder do Google Health AI. Você pode encontrar mais detalhes e modelos pré-treinados em google/medasr.

LasrCTCConfig

classe transformers.LasrCTCConfig

< >

( 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 = 512ctc_loss_reduction: str = 'mean'ctc_zero_infinity: bool = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 0 )

Parâmetros

  • vocab_size (int, opcional, padrão 512) — 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 LasrForCTC.
  • 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 LasrForCTC.
  • encoder_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone do codificador.
  • pad_token_id (int, opcional, padrão 0) — ID do token usado para preenchimento no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um LasrModel. Ela é usada para instanciar um modelo Lasr 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 google/medasr

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 LasrForCTC, LasrCTCConfig
>>> # Initializing a Lasr configuration
>>> configuration = LasrCTCConfig()
>>> # Initializing a model from the configuration
>>> model = LasrForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
This configuration class is based on the Lasr CTC architecture from Google Health AI. You can find more details and pre-trained models at [google/medasr](https://huggingface.co/google/medasr).

LasrEncoder

classe transformers.LasrEncoder

< >

( config: LasrEncoderConfig )

Parâmetros

  • config (LasrEncoderConfig) — 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 LasrEncoder, baseado na arquitetura Conformer](https://arxiv.org/abs/2005.08100).

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 | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LasrEncoderModelOutput 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) — Se deve retornar a máscara de atenção de saída.

Retorna

LasrEncoderModelOutput ou tuple(torch.Tensor)

Um LasrEncoderModelOutput 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 LasrEncoder 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.

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

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.

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

  • 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 após a compressão da sequência. Retornada porque o comprimento da sequência pode diferir do comprimento da sequência de entrada. Valores da máscara selecionados em [0, 1]:

    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

Exemplo:

>>> from transformers import AutoProcessor, LasrEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "google/medasr"
>>> 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)

LasrForCTC

classe transformers.LasrForCTC

< >

( config: LasrCTCConfig )

Parâmetros

  • config (LasrCTCConfig) — 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.

Lasr 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 LasrForCTC 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, LasrForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/lasr-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = LasrForCTC.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'> )

Exemplo:

>>> from transformers import AutoProcessor, LasrForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "google/medasr"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = LasrForCTC.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)
Update on GitHub

←Kyutai Speech-To-Text Mimi→