# LASR

## Resumen

LASR es la arquitectura que está detrás de MedASR, un modelo de voz a texto de Google Health AI preentrenado para dictado médico. Se basa en la [arquitectura Conformer](https://huggingface.co/papers/2005.08100) y está diseñado como punto de partida para los desarrolladores que crean herramientas de dictado con terminología médica, como el dictado de radiología. MedASR rinde bien con audio médico, pero puede tener dificultades con términos fuera de sus datos de entrenamiento, como nombres de medicamentos no estándar o referencias temporales (fechas, horas o duraciones).

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

### Entrenamiento

El siguiente ejemplo prepara un lote de audio y texto, lo pasa a través del modelo LASR/MedASR y calcula la pérdida de entrenamiento.

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

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

**Parámetros:**

vocab_file (`str`, *opcional*) : archivo [SentencePiece](https://github.com/google/sentencepiece) (generalmente con extensión *.spm*) que contiene el vocabulario necesario para instanciar un tokenizador.

eos_token (`str`, *opcional*, valor predeterminado `"</s>"`) : El token de fin de secuencia. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de secuencia. El token que se utiliza es `sep_token`.

unk_token (`str`, *opcional*, valor predeterminado `"<unk>"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

pad_token (`str`, *opcional*, valor predeterminado `"<pad>"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.

extra_ids (`int`, *opcional*, valor predeterminado 100) : Agrega un número de ids adicionales al vocabulario para usarlos como centinelas. Estos tokens son accesibles como "" donde "{%d}" es un número entre 0 y extra_ids-1. Estos tokens se pueden obtener llamando al método get_sentinel_tokens y los ids de los tokens se pueden obtener llamando al método get_sentinel_token_ids

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiales adicionales utilizados por el tokenizador.

vocab (`str`, `dict` o `list`, *opcional*) : Diccionario de vocabulario personalizado. Si no se proporciona, se crea un vocabulario mínimo utilizando los tokens especiales.

Construye un tokenizador LASR (respaldado por la biblioteca *tokenizers* de HuggingFace). Basado en [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).

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

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

```python
get_sentinel_token_ids()
```

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

Obtén los IDs de los tokens para los tokens centinela.

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

```python
get_sentinel_tokens()
```

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

Obtenga la lista de tokens centinela (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)
```

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

**Parámetros:**

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

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

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

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

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

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

Construye un extractor de características de LASR.

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

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

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

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

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

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

## LasrProcessor[[transformers.LasrProcessor]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lasr/processing_lasr.py#L33)

**Parámetros:**

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

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

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

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

#### __llamada__[[transformers.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.processing_utils.ProcessingKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lasr/processing_lasr.py#L50)

**Parámetros:**

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

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

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

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

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

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

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

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2054)

Este método reenvía todos sus argumentos a [batch_decode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2063)

Este método reenvía todos sus argumentos a [decode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) de PreTrainedTokenizer. Consulte la docstring de este método para obtener más información.

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

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

num_mel_bins (`int`, *opcional*, valor predeterminado `128`) : Número de características mel utilizadas por cada entrada de fotograma. Debe corresponder al valor utilizado en la clase `AutoFeatureExtractor`.

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

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

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

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

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

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

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

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

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

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

feed_forward_residual_weights (`tuple[float, float]`, *opcional*, valor predeterminado `[1.5, 0.5]`) : Los pesos residuales para las capas de avance hacia adelante.

conv_residual_weights (`tuple[float, float]`, *opcional*, valor predeterminado `[2.0, 1.0]`) : Los pesos residuales para las capas de convolución.

batch_norm_momentum (`float`, *opcional*, valor predeterminado 0.01) : El momento para las capas de normalización por lote

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

Esta es la clase de configuración para almacenar la configuración de un LasrModel. Se utiliza para instanciar un modelo Lasr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [google/medasr](https://huggingface.co/google/medasr)

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

Ejemplo:
```python
>>> from transformers import 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 clase de configuración se basa en la arquitectura LasrEncoder de Google Health AI. Puede encontrar más detalles y modelos preentrenados en [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)
```

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

**Parámetros:**

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

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

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

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

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

Esta es la clase de configuración para almacenar la configuración de un LasrModel. Se utiliza para instanciar un modelo Lasr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [google/medasr](https://huggingface.co/google/medasr)

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

Ejemplo:
```python
>>> from transformers import 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 clase de configuración se basa en la arquitectura Lasr CTC de Google Health AI. Puede encontrar más detalles y modelos preentrenados en [google/medasr](https://huggingface.co/google/medasr).

## LasrEncoder[[transformers.LasrEncoder]]

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

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

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

**Parámetros:**

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

El modelo LasrEncoder, basado en la arquitectura Conformer](https://arxiv.org/abs/2005.08100).

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

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

#### forward[[transformers.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'>)
```

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

**Parámetros:**

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

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

output_attention_mask (`bool`, *opcional*) : Si se debe devolver la máscara de atención de salida.

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

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

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

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

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **attention_mask** (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) -- Máscara para evitar realizar atención en los índices de tokens de relleno tras la compresión de la secuencia. Se devuelve porque la longitud de la secuencia puede diferir de la longitud de la secuencia de entrada. Valores de la máscara seleccionados en `[0, 1]`:

  - 1 para los tokens que **no están enmascarados**,
  - 0 para los tokens que están **enmascarados**.

Ejemplo:

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

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

**Parámetros:**

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

Lasr Encoder con una cabeza de Clasificación Temporal Conectiva (CTC).

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

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

#### forward[[transformers.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'>)
```

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

**Parámetros:**

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

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

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

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

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

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

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

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

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

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

Ejemplo:

```python
>>> from transformers import AutoProcessor, 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'>)
```

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

Ejemplo:

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

