# 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](https://huggingface.co/papers/2005.08100) 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

```python
from transformers import pipeline

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

```python
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor

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

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

inputs = processor(speech_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs)
print(processor.batch_decode(outputs))
```

### Treinamento

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

```python
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[[transformers.LasrTokenizer]]

#### transformers.LasrTokenizer[[transformers.LasrTokenizer]]

```python
transformers.LasrTokenizer(eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', _spm_precompiled_charsmap = None, extra_ids = 100, additional_special_tokens = None, vocab = None, vocab_file = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L33)

**Parâmetros:**

vocab_file (`str`, *opcional*) : arquivo [SentencePiece](https://github.com/google/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 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 "" 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](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).

Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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[[transformers.LasrTokenizer.get_sentinel_token_ids]]

```python
get_sentinel_token_ids()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L157)

Obtenha os IDs de tokens para tokens sentinel.

#### get_sentinel_tokens[[transformers.LasrTokenizer.get_sentinel_tokens]]

```python
get_sentinel_tokens()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/tokenization_lasr.py#L151)

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

## LasrFeatureExtractor[[transformers.LasrFeatureExtractor]]

#### transformers.LasrFeatureExtractor[[transformers.LasrFeatureExtractor]]

```python
transformers.LasrFeatureExtractor(feature_size = 128, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, padding_value = 0.0, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/feature_extraction_lasr.py#L70)

**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](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta 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__[[transformers.LasrFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = False, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'longest', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', return_token_timestamps: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/feature_extraction_lasr.py#L142)

**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 canal, 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 maiores 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 permitir 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 máscara de atenção. Se mantido no padrão, retornará a máscara de atenção de acordo com o padrão do feature_extractor específico.  [O que são máscaras de atenção?](../glossary#attention-mask)    Para os modelos Parakeet, `attention_mask` deve sempre ser passado para inferência em lote, para evitar bugs sutis.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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 preenchimento.

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 de sinais de áudio no método `_torch_extract_fbank_features`. (ex.: "cpu", "cuda")

return_token_timestamps (`bool`, *opcional*, padrão `None`) : Obsoleto. Use `return_attention_mask` em vez disso, a partir do qual o número de quadros pode ser inferido. Indica se o número de quadros da entrada raw_speech deve ser retornado ou não. Esses num_frames podem ser usados pelo modelo para calcular timestamps no nível de palavra.

Método principal para extrair características e preparar uma ou várias sequências 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[[transformers.LasrProcessor]]

#### transformers.LasrProcessor[[transformers.LasrProcessor]]

```python
transformers.LasrProcessor(feature_extractor, tokenizer)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/processing_lasr.py#L48)

**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](/docs/transformers/main/pt/model_doc/lasr#transformers.LasrProcessor) oferece todas as funcionalidades de `feature_extractor_class` e `tokenizer_class`. Consulte `~feature_extractor_class` e `~tokenizer_class` para mais informações.

#### __call__[[transformers.LasrProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], text: str | list[str] | list[list[str]] | None = None, sampling_rate: int | None = None, **kwargs: *<class 'transformers.models.lasr.processing_lasr.LasrProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/processing_lasr.py#L54)

**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 amostras 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 pretokenizada). Se você passar uma entrada pretokenizada, 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](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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[[transformers.LasrProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1948)

Este método encaminha todos os seus argumentos para o [batch_decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

#### decode[[transformers.LasrProcessor.decode]]

```python
decode(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1957)

Este método encaminha todos os seus argumentos para o [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

## LasrEncoderConfig[[transformers.LasrEncoderConfig]]

#### transformers.LasrEncoderConfig[[transformers.LasrEncoderConfig]]

```python
transformers.LasrEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 512, num_hidden_layers: int = 17, num_attention_heads: int = 8, intermediate_size: int = 2048, hidden_act: str = 'silu', attention_bias: bool = False, convolution_bias: bool = False, conv_kernel_size: int = 32, subsampling_conv_channels: int = 256, num_mel_bins: int = 128, subsampling_conv_kernel_size: int = 5, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 10000, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, feed_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.01, rope_parameters: dict | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/configuration_lasr.py#L29)

**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`) : 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 `False`) : Se deve usar 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 usado 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 de LayerDrop. Consulte o [artigo do LayerDrop](see 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 usado.

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 momento 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](https://huggingface.co/google/medasr)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```python
>>> 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](https://huggingface.co/google/medasr).

## LasrCTCConfig[[transformers.LasrCTCConfig]]

#### transformers.LasrCTCConfig[[transformers.LasrCTCConfig]]

```python
transformers.LasrCTCConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 512, ctc_loss_reduction: str = 'mean', ctc_zero_infinity: bool = True, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/configuration_lasr.py#L103)

**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](/docs/transformers/main/pt/model_doc/lasr#transformers.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](/docs/transformers/main/pt/model_doc/lasr#transformers.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](https://huggingface.co/google/medasr)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```python
>>> 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
```

Esta classe de configuração é baseada na arquitetura Lasr CTC do Google Health AI. Você pode encontrar mais detalhes e modelos pré-treinados em [google/medasr](https://huggingface.co/google/medasr).

## LasrEncoder[[transformers.LasrEncoder]]

#### transformers.LasrEncoder[[transformers.LasrEncoder]]

```python
transformers.LasrEncoder(config: LasrEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L465)

**Parâmetros:**

config ([LasrEncoderConfig](/docs/transformers/main/pt/model_doc/lasr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.LasrEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attention_mask: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L486)

**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 obter 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?](../glossary#attention-mask)

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](/docs/transformers/main/pt/model_doc/lasr#transformers.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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a 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 a 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 nas cabeças 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:

```python
>>> 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[[transformers.LasrForCTC]]

#### transformers.LasrForCTC[[transformers.LasrForCTC]]

```python
transformers.LasrForCTC(config: LasrCTCConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L601)

**Parâmetros:**

config ([LasrCTCConfig](/docs/transformers/main/pt/model_doc/lasr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.LasrForCTC.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L612)

**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 obter 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?](../glossary#attention-mask)

labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a 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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutput) ou `tuple(torch.Tensor)`

Um [CausalLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/lasr#transformers.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) com a 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 a 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.LasrForCTC.generate]]

```python
generate(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, return_dict_in_generate: bool = False, compile_config: transformers.generation.configuration_utils.CompileConfig | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lasr/modeling_lasr.py#L672)

Exemplo:

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