# Speech2Text

## Resumen

El modelo Speech2Text se propuso en [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://huggingface.co/papers/2010.05171) de Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko y Juan Pino. Es un modelo seq2seq (codificador-decodificador) basado en transformers, diseñado para el Reconocimiento Automático del Habla (ASR) y la Traducción del Habla (ST) de extremo a extremo. Utiliza un muestreador descendente convolucional para reducir la longitud de las entradas de habla en 3/4 antes de que se introduzcan en el codificador. El modelo se entrena con la pérdida de entropía cruzada autorregresiva estándar y genera las transcripciones/traducciones de forma autorregresiva. Speech2Text se ha ajustado en varios conjuntos de datos para ASR y ST: [LibriSpeech](http://www.openslr.org/12), [CoVoST 2](https://github.com/facebookresearch/covost), [MuST-C](https://ict.fbk.eu/must-c/).

Este modelo fue aportado por [valhalla](https://huggingface.co/valhalla). El código original se puede encontrar [aquí](https://github.com/pytorch/fairseq/tree/master/examples/speech_to_text).

## Inferencia

Speech2Text es un modelo de voz que acepta un tensor flotante de características de banco de filtros log-mel extraídas de la señal de voz. Es un modelo seq2seq basado en transformers, por lo que las transcripciones/traducciones se generan de forma autoregresiva. El método `generate()` se puede utilizar para la inferencia.

La clase [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) se encarga de extraer las características del banco de filtros log-mel. [Speech2TextProcessor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextProcessor) agrupa [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) y [Speech2TextTokenizer](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextTokenizer) en una única instancia para extraer las características de entrada y decodificar los ids de tokens predichos.

El extractor de características depende de `torchaudio` y el tokenizador depende de `sentencepiece`, por lo que asegúrese de instalar esos paquetes antes de ejecutar los ejemplos. Puede instalarlos como dependencias adicionales de voz con `pip install transformers"[speech, sentencepiece]"` o instalar los paquetes por separado con `pip install torchaudio sentencepiece`. Además, `torchaudio` requiere la versión de desarrollo del paquete [libsndfile](http://www.mega-nerd.com/libsndfile/), que se puede instalar mediante un gestor de paquetes del sistema. En Ubuntu, se puede instalar de la siguiente manera: `apt install libsndfile1-dev`

- ASR y traducción de voz

```python
from datasets import load_dataset

from transformers import Speech2TextForConditionalGeneration, Speech2TextProcessor

model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr", device_map="auto")
processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt").to(model.device)
generated_ids = model.generate(inputs["input_features"], attention_mask=inputs["attention_mask"])

transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
transcription
['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']
```

- Traducción de voz multilingüe

  En los modelos de traducción de voz multilingües, `eos_token_id` se utiliza como `decoder_start_token_id` y el identificador del idioma de destino se fuerza como el primer token generado. Para forzar el identificador del idioma de destino como el primer token generado, pase el parámetro `forced_bos_token_id` al método `generate()`. El siguiente ejemplo muestra cómo traducir voz en inglés a texto en francés utilizando el punto de control *facebook/s2t-medium-mustc-multilingual-st*.

```python
from datasets import load_dataset

from transformers import Speech2TextForConditionalGeneration, Speech2TextProcessor

model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-medium-mustc-multilingual-st", device_map="auto")
processor = Speech2TextProcessor.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")

ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt").to(model.device)
generated_ids = model.generate(
    inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    forced_bos_token_id=processor.tokenizer.lang_code_to_id["fr"],
)

translation = processor.batch_decode(generated_ids, skip_special_tokens=True)
translation
["(Vidéo) Si M. Kilder est l'apossible des classes moyennes, et nous sommes heureux d'être accueillis dans son évangile."]
```

Consulte el [model hub](https://huggingface.co/models?filter=speech_to_text) para buscar puntos de control de Speech2Text.

## Speech2TextConfig[[transformers.Speech2TextConfig]]

#### transformers.Speech2TextConfig[[transformers.Speech2TextConfig]]

```python
transformers.Speech2TextConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 10000, encoder_layers: int = 12, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 4, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 4, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, decoder_start_token_id: int = 2, scale_embedding: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_source_positions: int = 6000, max_target_positions: int = 1024, num_conv_layers: int = 2, conv_kernel_sizes: list[int] | tuple[int, ...] = (5, 5), conv_channels: int = 1024, input_feat_per_channel: int = 80, input_channels: int = 1, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/configuration_speech_to_text.py#L24)

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

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

encoder_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el codificador Transformer. Usará el mismo valor que `num_layers` si no se establece.

encoder_ffn_dim (`int`, *opcional*, valor predeterminado `2048`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el codificador.

encoder_attention_heads (`int`, *opcional*, valor predeterminado `4`) : Número de cabezas de atención para cada capa de atención en el codificador Transformer.

decoder_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador Transformer. Usará el mismo valor que `num_layers` si no se establece.

decoder_ffn_dim (`int`, *opcional*, valor predeterminado `2048`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el decodificador.

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

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

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

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

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

d_model (`int`, *opcional*, valor predeterminado `256`) : Tamaño de las capas del codificador y de la capa pooler.

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

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

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

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

decoder_start_token_id (`int`, *opcional*, valor predeterminado `2`) : Si un modelo encoder-decoder comienza a decodificar con un token diferente de `bos`, el id de ese token.

scale_embedding (`bool`, *opcional*, valor predeterminado `True`) : Si se deben escalar los embeddings dividiendo por sqrt(d_model).

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

bos_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el fin de la secuencia en el vocabulario.

max_source_positions (`int`, *opcional*, valor predeterminado 6000) : La longitud máxima de secuencia de características de banco de filtros log-mel con la que este modelo podría llegar a utilizarse.

max_target_positions (`int`, *opcional*, valor predeterminado 1024) : La longitud máxima de secuencia con la que se podría utilizar este modelo. Por lo general, se recomienda establecer un valor alto por si acaso (p. ej., 512, 1024 o 2048).

num_conv_layers (`int`, *opcional*, valor predeterminado 2) : Número de capas de convolución 1D en el módulo conv.

conv_kernel_sizes (`tuple[int]`, *opcional*, valor predeterminado `(5, 5)`) : Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el módulo conv. La longitud de `conv_kernel_sizes` debe coincidir con `num_conv_layers`.

conv_channels (`int`, *opcional*, valor predeterminado 1024) : Un entero que define el número de canales de salida de cada capa de convolución, excepto la última, en el módulo conv.

input_feat_per_channel (`int`, *opcional*, valor predeterminado: 80) : Un entero que especifica el tamaño del vector de características. También corresponde a las dimensiones de las características del banco de filtros log-mel.

input_channels (`int`, *opcional*, valor predeterminado `1`) : El número de canales de entrada.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un Speech2TextModel. Se utiliza para instanciar un modelo de Speech To Text 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 [facebook/s2t-small-librispeech-asr](https://huggingface.co/facebook/s2t-small-librispeech-asr)

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 Speech2TextConfig, Speech2TextModel

>>> # Initializing a Speech2Text s2t_transformer_s style configuration
>>> configuration = Speech2TextConfig()

>>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
>>> model = Speech2TextModel(configuration)

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

## Speech2TextTokenizer[[transformers.Speech2TextTokenizer]]

#### transformers.Speech2TextTokenizer[[transformers.Speech2TextTokenizer]]

```python
transformers.Speech2TextTokenizer(vocab_file, spm_file, bos_token = '<s>', eos_token = '</s>', pad_token = '<pad>', unk_token = '<unk>', do_upper_case = False, do_lower_case = False, tgt_lang = None, lang_codes = None, additional_special_tokens = None, sp_model_kwargs: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L49)

**Parámetros:**

vocab_file (`str`) : Archivo que contiene el vocabulario.

spm_file (`str`) : Ruta al archivo de modelo de [SentencePiece](https://github.com/google/sentencepiece)

bos_token (`str`, *opcional*, valor predeterminado `"<s>"`) : El token de inicio de oración.

eos_token (`str`, *opcional*, por defecto `"</s>"`) : El token de fin de oración.

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.

do_upper_case (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe convertir la salida a mayúsculas durante la decodificación.

do_lower_case (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe convertir la entrada en minúsculas al tokenizar.

tgt_lang (`str`, *opcional*) : Una cadena que representa el idioma de destino.

sp_model_kwargs (`dict`, *opcional*) : Se pasará al método `SentencePieceProcessor.__init__()`. El [envoltorio de Python para SentencePiece](https://github.com/google/sentencepiece/tree/master/python) se puede utilizar, entre otras cosas, para establecer:  - `enable_sampling`: Habilita la regularización de subpalabras. - `nbest_size`: Parámetros de muestreo para unigramas. No válido para BPE-Dropout.  - `nbest_size = {0,1}`: No se realiza muestreo. - `nbest_size > 1`: muestrea de los resultados de nbest_size. - `nbest_size < 0`: asume que nbest_size es infinito y muestrea de todas las hipótesis (lattice) utilizando el algoritmo de filtrado hacia adelante y muestreo hacia atrás.  - `alpha`: Parámetro de suavizado para el muestreo de unigramas y probabilidad de dropout de las operaciones de fusión para BPE-dropout.

- ****kwargs** : Argumentos de palabra clave adicionales que se pasan a [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)

Construya un tokenizador de Speech2Text.

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

#### build_inputs_with_special_tokens[[transformers.Speech2TextTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0, token_ids_1 = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L206)

Construir las entradas del modelo a partir de una secuencia añadiendo eos_token_id.

#### get_special_tokens_mask[[transformers.Speech2TextTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L213)

**Parámetros:**

token_ids_0 (`list[int]`) : Lista de IDs.

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de secuencias.

already_has_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si la lista de tokens ya está formateada con tokens especiales para el modelo.

**Devuelve:** `list[int]`

Una lista de enteros en el rango [0, 1]: 1 para un token especial, 0 para un token de secuencia.

Obtiene los ids de secuencia de una lista de tokens a la que no se le han añadido tokens especiales. Este método se llama al añadir tokens especiales mediante el método `prepare_for_model` del tokenizer.

#### create_token_type_ids_from_sequences[[transformers.Speech2TextTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

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

**Parámetros:**

token_ids_0 (`list[int]`) : Lista de IDs.

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de secuencias.

**Devuelve:** `list[int]`

IDs de tipo de token según el patrón configurado.

Crea una máscara a partir de las dos secuencias pasadas para ser utilizada en una tarea de clasificación de pares de secuencias.

Este método construye dinámicamente los IDs de tipo de token en función de los atributos de configuración del tokenizador:
- `token_type_ids_pattern`: Patrón a utilizar ("all_zeros" o "bert_style")
- `token_type_ids_include_special_tokens`: Si se deben tener en cuenta los tokens especiales en el cálculo de la longitud

Ejemplos:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.Speech2TextTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/tokenization_speech_to_text.py#L257)

## Speech2TextFeatureExtractor[[transformers.Speech2TextFeatureExtractor]]

#### transformers.Speech2TextFeatureExtractor[[transformers.Speech2TextFeatureExtractor]]

```python
transformers.Speech2TextFeatureExtractor(feature_size = 80, sampling_rate = 16000, num_mel_bins = 80, padding_value = 0.0, dither = 0.0, do_ceptral_normalize = True, normalize_means = True, normalize_vars = True, **kwargs)
```

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

**Parámetros:**

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

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

num_mel_bins (`int`, *opcional*, valor predeterminado 80) : Número de bandas de frecuencia Mel.

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

dither (`float`, *opcional*, valor predeterminado 0.0) : Añade dithering. En otras palabras, añade un pequeño ruido gaussiano a cada fotograma. Por ejemplo, use 4.0 para añadir dithering con una distribución normal centrada en 0.0 y desviación estándar 4.0 (asumiendo un rango de [-32k,+32k] para la forma de onda de kaldi). El valor 0.0 significa sin dithering. El dithering tiene un efecto similar al de `mel_floor`. Reduce los valores altos de log_mel_fbank para señales con secciones de cero duro, cuando hay un corte de VAD en la señal.

do_ceptral_normalize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se aplica o no la normalización de media y varianza cepstral a nivel de enunciado a las características extraídas.

normalize_means (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar con media cero las características extraídas.

normalize_vars (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar las características extraídas con varianza unitaria.

Construye un extractor de características de Speech2Text.

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

Esta clase extrae características de banco de filtros mel de audio bruto usando TorchAudio si está instalado, o numpy en caso contrario, y aplica normalización de media y varianza cepstral a nivel de enunciado a las características extraídas.

#### __llamada__[[transformers.Speech2TextFeatureExtractor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/feature_extraction_speech_to_text.py#L174)

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

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede devolver un lote con secuencias de longitudes diferentes).

max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba).

truncation (`bool`) : Activa el recorte para cortar las secuencias de entrada más largas que *max_length* hasta *max_length*.

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

return_attention_mask (`bool`, *opcional*) : Indica 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 Speech2TextTransformer, `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:  - `'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.

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

Método principal para extraer características y preparar una o varias secuencias para el modelo.

## Speech2TextProcessor[[transformers.Speech2TextProcessor]]

#### transformers.Speech2TextProcessor[[transformers.Speech2TextProcessor]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/processing_speech_to_text.py#L23)

**Parámetros:**

feature_extractor (`Speech2TextFeatureExtractor`): el extractor de características es una entrada obligatoria.

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

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

[Speech2TextProcessor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextProcessor) ofrece todas las funcionalidades de [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) y [Speech2TextTokenizer](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextTokenizer). Consulte [~Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) y [~Speech2TextTokenizer](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextTokenizer) para obtener más información.

#### __llamada__[[transformers.Speech2TextProcessor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/processing_speech_to_text.py#L27)

**Parámetros:**

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.

#### from_pretrained[[transformers.Speech2TextProcessor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

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

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : Puede ser cualquiera de las siguientes opciones: - una cadena, el *model id* de un feature_extractor preentrenado alojado en un repositorio de modelos en huggingface.co. - una ruta a un *directorio* que contiene un archivo de feature extractor guardado mediante el método [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), por ejemplo, `./my_model_directory/`. - una ruta a un *archivo* JSON de feature extractor guardado, por ejemplo, `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Argumentos de palabra clave adicionales que se pasan tanto a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) como a `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instanciar un procesador asociado con un modelo preentrenado.

Este método de clase simplemente llama al método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) del extractor de características, al método [ImageProcessingMixin](/docs/transformers/v5.23.0/es/internal/image_processing_utils#transformers.ImageProcessingMixin) del procesador de imágenes y al método `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` del tokenizador. Consulte las docstrings de los métodos anteriores para obtener más información.

#### save_pretrained[[transformers.Speech2TextProcessor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON del feature extractor y los archivos del tokenizer (se creará el directorio si no existe).

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarda los atributos de este procesador (extractor de características, tokenizador...) en el directorio especificado para que pueda recargarse mediante el método [from_pretrained()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Este método de clase simplemente llama a [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) y [save_pretrained()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Consulte las docstrings de los métodos anteriores para obtener más información.

#### batch_decode[[transformers.Speech2TextProcessor.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.Speech2TextProcessor.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.

## Speech2TextModel[[transformers.Speech2TextModel]]

#### transformers.Speech2TextModel[[transformers.Speech2TextModel]]

```python
transformers.Speech2TextModel(config: Speech2TextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L720)

**Parámetros:**

config ([Speech2TextConfig](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextConfig)) : 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 de texto a texto de voz sin procesar que genera estados ocultos sin ningún cabezal específico en la parte superior.

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.Speech2TextModel.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L736)

**Parámetros:**

input_features (`torch.LongTensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor). Consulte [Speech2TextFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor.__call__) para obtener más detalles ([Speech2TextProcessor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextProcessor) utiliza [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) 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)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener mediante `SpeechToTextTokenizer`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) SpeechToText utiliza `eos_token_id` como token inicial para la generación de `decoder_input_ids`. Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `modeling_speech_to_text._prepare_decoder_attention_mask` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) para obtener más información sobre la estrategia predeterminada.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `decoder_input_ids`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. Si `decoder_input_ids` y `decoder_inputs_embeds` no están configurados, `decoder_inputs_embeds` toma el valor de `inputs_embeds`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

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

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 ([Speech2TextConfig](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextConfig)) y las entradas.

El método forward de [Speech2TextModel](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextModel) reemplaza 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.
- **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).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
- **decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
- **encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> import torch
>>> from transformers import Speech2TextModel, AutoFeatureExtractor
>>> from datasets import load_dataset

>>> model = Speech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 256]
```

## Speech2TextForConditionalGeneration[[transformers.Speech2TextForConditionalGeneration]]

#### transformers.Speech2TextForConditionalGeneration[[transformers.Speech2TextForConditionalGeneration]]

```python
transformers.Speech2TextForConditionalGeneration(config: Speech2TextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L842)

**Parámetros:**

config ([Speech2TextConfig](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextConfig)) : 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 Speech2Text con una cabeza de modelado de lenguaje. Puede usarse para la resumición.

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.Speech2TextForConditionalGeneration.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speech_to_text/modeling_speech_to_text.py#L855)

**Parámetros:**

input_features (`torch.LongTensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor). Consulte [Speech2TextFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor.__call__) para obtener más detalles ([Speech2TextProcessor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextProcessor) utiliza [Speech2TextFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextFeatureExtractor) 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)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener mediante `SpeechToTextTokenizer`. Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) SpeechToText utiliza `eos_token_id` como token inicial para la generación de `decoder_input_ids`. Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`).

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `modeling_speech_to_text._prepare_decoder_attention_mask` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) para obtener más información sobre la estrategia predeterminada.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `decoder_input_ids`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. Si `decoder_input_ids` y `decoder_inputs_embeds` no están configurados, `decoder_inputs_embeds` toma el valor de `inputs_embeds`.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje. 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]`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

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

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 ([Speech2TextConfig](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextConfig)) y las entradas.

El método forward de [Speech2TextForConditionalGeneration](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextForConditionalGeneration) 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.
- **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).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
- **decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
- **encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset

>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
```

