# Wav2Vec2

## Resumen

El modelo Wav2Vec2 fue propuesto en [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://huggingface.co/papers/2006.11477) por Alexei Baevski, Henry Zhou, Abdelrahman Mohamed y Michael Auli.

El resumen del artículo es el siguiente:

*Por primera vez, demostramos que aprender representaciones potentes a partir únicamente de audio de voz y, a continuación, realizar un ajuste fino con voz transcrita puede superar a los mejores métodos semisupervisados, siendo además conceptualmente más simple. wav2vec 2.0 enmascara la entrada de voz en el espacio latente y resuelve una tarea contrastiva definida sobre una cuantización de las representaciones latentes, que se aprenden de forma conjunta. Los experimentos que utilizan todos los datos etiquetados de Librispeech logran un WER de 1.8/3.3 en los conjuntos de prueba clean/other. Al reducir la cantidad de datos etiquetados a una hora, wav2vec 2.0 supera al estado del arte anterior en el subconjunto de 100 horas, utilizando 100 veces menos datos etiquetados. Utilizando solo diez minutos de datos etiquetados y preentrenando con 53k horas de datos sin etiquetar, se logra un WER de 4.8/8.2. Esto demuestra la viabilidad del reconocimiento de voz con cantidades limitadas de datos etiquetados.*

Este modelo fue aportado por [patrickvonplaten](https://huggingface.co/patrickvonplaten).

Nota: Meta (FAIR) ha publicado una nueva versión de [Wav2Vec2-BERT 2.0](./wav2vec2-bert), preentrenada con 4,5 millones de horas de audio. Recomendamos especialmente su uso en tareas de fine-tuning, por ejemplo, siguiendo [esta guía](https://huggingface.co/blog/fine-tune-w2v2-bert).

> [!TIP]
> Establezca `use_kernels=True` en [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte [Carga de kernels](../kernel_doc/loading_kernels) para obtener más información.

## Consejos de uso

- Wav2Vec2 es un modelo de voz que acepta un array de flotantes correspondiente a la forma de onda cruda de la señal de voz.
- El modelo Wav2Vec2 se entrenó mediante clasificación temporal conexionista (CTC), por lo que la salida del modelo debe decodificarse con [Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).

## Uso de Flash Attention 2

Flash Attention 2 es una versión más rápida y optimizada del modelo.

### Instalación

Primero, comprueba si tu hardware es compatible con Flash Attention 2. La lista más reciente de hardware compatible se encuentra en la [documentación oficial](https://github.com/Dao-AILab/flash-attention#installation-and-features).

A continuación, [instale](https://github.com/Dao-AILab/flash-attention#installation-and-features) la última versión de Flash Attention 2:

```bash
pip install -U flash-attn --no-build-isolation
```

### Uso

Para cargar un modelo usando Flash Attention 2, podemos pasar el argumento `attn_implementation="flash_attention_2"` a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained). También cargaremos el modelo en media precisión (por ejemplo, `torch.float16`), ya que esto produce una degradación casi nula en la calidad del audio, pero reduce significativamente el uso de memoria y acelera la inferencia:

```python
from transformers import Wav2Vec2Model

model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...
```

### Aceleraciones esperadas

A continuación se muestra un diagrama de la aceleración esperada que compara el tiempo de inferencia puro entre la implementación nativa en transformers del modelo `facebook/wav2vec2-large-960h-lv60-self` y las versiones flash-attention-2 y sdpa (scale-dot-product-attention). Mostramos la aceleración media obtenida en la división de validación `librispeech_asr` `clean`:

## Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con Wav2Vec2. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.

- Un cuaderno sobre cómo [aprovechar un modelo Wav2Vec2 preentrenado para la clasificación de emociones](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) es compatible con este [cuaderno](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb).
- [Guía de la tarea de clasificación de audio](../tasks/audio_classification)

- Una entrada de blog sobre [mejorar Wav2Vec2 con n-gramas en 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- Una publicación de blog sobre cómo [ajustar Wav2Vec2 para ASR en inglés con 🤗 Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- Una publicación de blog sobre [el ajuste fino de XLS-R para ASR multilingüe con 🤗 Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- Un cuaderno sobre cómo [crear subtítulos de YouTube a partir de cualquier video transcribiendo el audio con Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) cuenta con un cuaderno de notas sobre [cómo ajustar un modelo de reconocimiento de voz en inglés](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb) y [cómo ajustar un modelo de reconocimiento de voz en cualquier idioma](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).
- [Guía de la tarea de reconocimiento automático del habla](../tasks/asr)

🚀 Despliegue

- Una publicación de blog sobre cómo desplegar Wav2Vec2 para [Reconocimiento Automático del Habla con Transformers de Hugging Face y Amazon SageMaker](https://www.philschmid.de/automatic-speech-recognition-sagemaker).

## Wav2Vec2Config[[transformers.Wav2Vec2Config]]

#### transformers.Wav2Vec2Config[[transformers.Wav2Vec2Config]]

```python
transformers.Wav2Vec2Config(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 | None = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, feat_extract_norm: str = 'group', feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, do_stable_layer_norm: bool = False, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500), tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1), tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1), xvector_output_dim: int = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 3, output_hidden_size: int | None = None, adapter_attn_dim: int | None = None)
```

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

**Parámetros:**

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

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

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

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

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

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

hidden_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

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.

feat_proj_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para la salida del codificador de características.

feat_quantizer_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para la salida del codificador de características que utiliza el cuantizador.

final_dropout (`float`, *opcional*, valor predeterminado 0.1) : La probabilidad de dropout para la capa de proyección final de [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

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.

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-05`) : El epsilon utilizado por las capas de normalización de capas.

feat_extract_norm (`str`, *opcional*, valor predeterminado `"group"`) : La normalización que se aplicará a las capas convolucionales 1D del codificador de características. Puede ser `"group"` para la normalización por grupos solo de la primera capa convolucional 1D, o `"layer"` para la normalización por capas de todas las capas convolucionales 1D.

feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.

conv_dim (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(512, 512, 512, 512, 512, 512, 512)`) : Una tupla de enteros que define el número de canales de entrada y salida de cada capa convolucional 1D en el codificador de características. La longitud de *conv_dim* define el número de capas convolucionales 1D.

conv_stride (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(5, 2, 2, 2, 2, 2, 2)`) : Una tupla de enteros que define el paso de cada capa convolucional 1D en el codificador de características. La longitud de *conv_stride* define el número de capas convolucionales y debe coincidir con la longitud de *conv_dim*.

conv_kernel (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(10, 3, 3, 3, 3, 3, 3)`) : Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el codificador de características. La longitud de *conv_kernel* define el número de capas convolucionales y debe coincidir con la longitud de *conv_dim*.

conv_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si las capas de convolución 1D tienen un sesgo.

num_conv_pos_embeddings (`int`, *opcional*, valor predeterminado 128) : Número de incrustaciones posicionales convolucionales. Define el tamaño del núcleo de la capa de incrustaciones posicionales convolucionales 1D.

num_conv_pos_embedding_groups (`int`, *opcional*, valor predeterminado 16) : Número de grupos de la capa de embeddings posicionales de convolución 1D.

do_stable_layer_norm (`bool`, *opcional*, valor predeterminado `False`) : Si se aplica la arquitectura de *stable* layer norm del codificador Transformer. `do_stable_layer_norm is True` corresponde a aplicar layer norm antes de la capa de atención, mientras que `do_stable_layer_norm is False` corresponde a aplicar layer norm después de la capa de atención.

apply_spec_augment (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar la ampliación de datos *SpecAugment* a las salidas del codificador de características. Para más información, consulte [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779).

mask_time_prob (`float`, *opcional*, valor predeterminado 0.05) : Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje temporal que se enmascararán. El procedimiento de enmascarado genera ''mask_time_prob*len(time_axis)/mask_time_length'' máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como inicio del tramo de vectores a enmascarar, *mask_time_prob* debería ser `prob_vector_start*mask_time_length`. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si `apply_spec_augment is True`.

mask_time_length (`int`, *opcional*, valor predeterminado 10) : Longitud de la extensión del vector a lo largo del eje temporal.

mask_time_min_masks (`int`, *opcional*, valor predeterminado 2), : El número mínimo de máscaras de longitud `mask_feature_length` generadas a lo largo del eje temporal, en cada paso de tiempo, independientemente de `mask_feature_prob`. Solo es relevante si ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks''

mask_feature_prob (`float`, *opcional*, valor predeterminado 0.0) : Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje de características que se enmascararán. El procedimiento de enmascarado genera ''mask_feature_prob*len(feature_axis)/mask_time_length'' máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como inicio del tramo de vectores a enmascarar, *mask_feature_prob* debería ser `prob_vector_start*mask_feature_length`. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si `apply_spec_augment is True`.

mask_feature_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : Porcentaje (entre 0 y 1) de todos los vectores de características a lo largo del eje de características que se enmascararán. El procedimiento de enmascarado genera `mask_feature_prob*len(feature_axis)/mask_time_length` máscaras independientes sobre el eje. Si se razona a partir de la probabilidad de que cada vector de características sea elegido como inicio del tramo de vectores a enmascarar, *mask_feature_prob* debería ser `prob_vector_start*mask_feature_length`. Tenga en cuenta que la superposición puede disminuir el porcentaje real de vectores enmascarados. Esto solo es relevante si `apply_spec_augment` es `True`.

mask_feature_length (`int`, *opcional*, valor predeterminado 10) : Longitud de la extensión del vector a lo largo del eje de características.

mask_feature_min_masks (`int`, *opcional*, valor predeterminado 0): el número mínimo de máscaras de longitud `mask_feature_length` generadas a lo largo del eje de características en cada paso de tiempo, independientemente de `mask_feature_prob`. Solo es relevante si ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''

num_codevectors_per_group (`int`, *opcional*, valor predeterminado 320) : Número de entradas en cada libro de cuantización (grupo).

num_codevectors_per_group (`int`, *opcional*, valor predeterminado 320) : Número de entradas en cada libro de cuantización (grupo).

num_codevector_groups (`int`, *opcional*, valor predeterminado 2) : Número de grupos de codevector para la cuantización de codevector por producto.

contrastive_logits_temperature (`float`, *opcional*, valor predeterminado 0.1) : La temperatura *kappa* en la pérdida contrastiva.

num_negatives (`int`, *opcional*, valor predeterminado 100) : Número de muestras negativas para la pérdida contrastiva.

codevector_dim (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de los vectores de características cuantizados.

proj_codevector_dim (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de la proyección final de las características cuantizadas y de las características del transformador.

diversity_loss_weight (`int`, *opcional*, valor predeterminado 0.1) : El peso del componente de pérdida de diversidad del libro de códigos.

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

ctc_zero_infinity (`bool`, *opcional*, valor predeterminado `False`) : 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 dianas. Solo es relevante al entrenar una instancia de [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

use_weighted_layer_sum (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar una media ponderada de las salidas de las capas con pesos aprendidos. Solo es relevante al usar una instancia de [Wav2Vec2ForSequenceClassification](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification).

classifier_proj_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de la proyección antes del token mean-pooling para clasificación.

tdnn_dim (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(512, 512, 512, 512, 1500)`) : Una tupla de enteros que define el número de canales de salida de cada capa convolucional 1D en el módulo *TDNN* del modelo *XVector*. La longitud de *tdnn_dim* define el número de capas *TDNN*.

tdnn_kernel (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(5, 3, 3, 1, 1)`) : Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en el módulo *TDNN* del modelo *XVector*. La longitud de *tdnn_kernel* debe coincidir con la longitud de *tdnn_dim*.

tdnn_dilation (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `(1, 2, 3, 1, 1)`) : Una tupla de enteros que define el factor de dilatación de cada capa convolucional 1D en el módulo *TDNN* del modelo *XVector*. La longitud de *tdnn_dilation* debe coincidir con la longitud de *tdnn_dim*.

xvector_output_dim (`int`, *opcional*, valor predeterminado 512) : Dimensionalidad de los vectores de incrustación *XVector*.

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

bos_token_id (`int`, *opcional*, valor predeterminado `1`) : Identificador 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.

add_adapter (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe apilar una red convolucional sobre el codificador de Wav2Vec2. Puede ser muy útil para iniciar el entrenamiento de Wav2Vec2 para modelos SpeechEncoderDecoder.

adapter_kernel_size (`int`, *opcional*, valor predeterminado 3) : Tamaño del kernel de las capas convolucionales en la red del adaptador. Solo es relevante si `add_adapter is True`.

adapter_stride (`int`, *opcional*, valor predeterminado 2) : Paso de las capas convolucionales en la red del adaptador. Solo es relevante si `add_adapter is True`.

num_adapter_layers (`int`, *opcional*, valor predeterminado 3) : Número de capas convolucionales que deben usarse en la red del adaptador. Solo es relevante si `add_adapter is True`.

output_hidden_size (`int`, *opcional*) : Dimensionalidad de la capa de salida del codificador. Si no se define, el valor predeterminado es *hidden-size*. Solo es relevante si `add_adapter is True`.

adapter_attn_dim (`int`, *opcional*) : Dimensión de los pesos del adaptador de atención que se utilizará en cada bloque de atención. Un ejemplo de un modelo que utiliza adaptadores de atención es [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

Esta es la clase de configuración para almacenar la configuración de un Wav2Vec2Model. Se utiliza para instanciar un modelo Wav2Vec2 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/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h)

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 Wav2Vec2Config, Wav2Vec2Model

>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)

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

## Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

#### transformers.Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

```python
transformers.Wav2Vec2CTCTokenizer(vocab_file, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', word_delimiter_token = '|', replace_word_delimiter_char = ' ', do_lower_case = False, target_lang = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L101)

**Parámetros:**

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

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.

word_delimiter_token (`str`, *opcional*, valor predeterminado `"|"`) : El token utilizado para definir el final de una palabra.

do_lower_case (`bool`, *opcional*, valor predeterminado `False`) : Indica si se acepta la entrada en minúsculas y se convierte la salida a minúsculas durante la decodificación.

target_lang (`str`, *opcional*) : Un idioma objetivo que el tokenizador debe establecer de forma predeterminada. `target_lang` debe estar definido para vocabularios anidados multilingües, como [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

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

Construye un tokenizador Wav2Vec2CTC.

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.

#### __llamada__[[transformers.Wav2Vec2CTCTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**Parámetros:**

text (`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 (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair (`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 (cadenas pretokenizadas). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas (pretokenizadas), debe establecer `is_split_into_words=True` (para eliminar la ambigüedad con un lote de secuencias).

tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos.

add_special_tokens (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si desea añadir automáticamente tokens `bos` o `eos`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `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 generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca 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. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca 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. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca 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. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

stride (`int`, *opcional*, valor predeterminado 0) : Si se establece en un número junto con `max_length`, los tokens en exceso devueltos cuando `return_overflowing_tokens=True` contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de exceso. El valor de este argumento define el número de tokens superpuestos.

is_split_into_words (`bool`, *opcional*, valor predeterminado `False`) : Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece en `True`, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y procederá a tokenizarla. Esto es útil para NER o clasificación de tokens.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre ['right', 'left']. El valor predeterminado se toma del atributo de la clase con el mismo nombre.

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.

return_token_type_ids (`bool`, *opcional*) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

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 tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las secuencias de tokens que desbordan. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con `truncation_strategy = longest_first` o `True`, se genera un error en lugar de devolver los tokens que desbordan.

return_special_tokens_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe o no devolver información de la máscara de tokens especiales.

return_offsets_mapping (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `(char_start, char_end)` para cada token. Esto solo está disponible en tokenizadores rápidos que heredan de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend); si se utiliza el tokenizador de Python, este método lanzará `NotImplementedError`.

return_length  (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las longitudes de las entradas codificadas.

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

- ****kwargs** : se pasan al método `self.tokenize()`

**Devuelve:** [BatchEncoding](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.BatchEncoding)

Un [BatchEncoding](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos:

- **input_ids** -- Lista de ids de tokens que se enviarán a un modelo.

  [¿Qué son los IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token que se enviarán a un modelo (cuando `return_token_type_ids=True` o si *"token_type_ids"* está en `self.model_input_names`).

  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

- **attention_mask** -- Lista de índices que especifica qué tokens debe atender el modelo (cuando `return_attention_mask=True` o si *"attention_mask"* está en `self.model_input_names`).

  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

- **overflowing_tokens** -- Lista de secuencias de tokens que exceden el límite (cuando se especifica `max_length` y `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (cuando se especifica un `max_length` y `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0 y 1, donde 1 indica tokens especiales añadidos y 0 indica tokens regulares de la secuencia (cuando `add_special_tokens=True` y `return_special_tokens_mask=True`).
- **length** -- La longitud de las entradas (cuando `return_length=True`)

Método principal para tokenizar y preparar una o varias secuencias o uno o varios pares de secuencias para el modelo.

#### save_vocabulary[[transformers.Wav2Vec2CTCTokenizer.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/wav2vec2/tokenization_wav2vec2.py#L643)

#### decode[[transformers.Wav2Vec2CTCTokenizer.decode]]

```python
decode(token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L538)

**Parámetros:**

token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Se puede obtener mediante el método `__call__`.

skip_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar o no los tokens especiales durante la decodificación.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar o no los espacios de tokenización.

output_char_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de caracteres. Los desplazamientos de caracteres pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de los caracteres transcritos. Consulte el ejemplo siguiente para comprender mejor cómo utilizar `output_char_offsets`.

output_word_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras pueden utilizarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas. Consulte el ejemplo siguiente para comprender mejor cómo utilizar `output_word_offsets`.

kwargs (argumentos de palabra clave adicionales, *opcional*) : Se pasarán al método de decodificación específico del modelo subyacente.

**Devuelve:** `str` o `Wav2Vec2CTCTokenizerOutput`

La lista de frases decodificadas. Será un `Wav2Vec2CTCTokenizerOutput` cuando `output_char_offsets == True` o `output_word_offsets == True`.

Convierte una secuencia de ids en una cadena de texto, utilizando el tokenizador y el vocabulario, con opciones para eliminar tokens especiales y limpiar los espacios de tokenización.

Similar a hacer `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

Ejemplo:

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]
```

#### batch_decode[[transformers.Wav2Vec2CTCTokenizer.batch_decode]]

```python
batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L468)

**Parámetros:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Se puede obtener mediante el método `__call__`.

skip_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar o no los tokens especiales durante la decodificación.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar o no los espacios de tokenización.

output_char_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de caracteres. Los desplazamientos de caracteres pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de los caracteres transcritos.    Consulte el Ejemplo de [decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) para comprender mejor cómo utilizar `output_char_offsets`. [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) funciona de la misma manera con salidas por lotes.

output_word_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras se pueden utilizar en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas. Consulte el Ejemplo de [decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) para comprender mejor cómo utilizar `output_word_offsets`. [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) funciona de la misma manera con la salida por lotes.

kwargs (argumentos de palabra clave adicionales, *opcional*) : Se pasarán al método de decodificación específico del modelo subyacente.

**Devuelve:** `list[str]` o `Wav2Vec2CTCTokenizerOutput`

La lista de frases decodificadas. Será un `Wav2Vec2CTCTokenizerOutput` cuando `output_char_offsets == True` o `output_word_offsets == True`.

Convierta una lista de listas de ids de tokens en una lista de cadenas de texto llamando a decode.

#### set_target_lang[[transformers.Wav2Vec2CTCTokenizer.set_target_lang]]

```python
set_target_lang(target_lang: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L184)

Establecer el idioma objetivo de un diccionario multinivel multilingüe

## Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

#### transformers.Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

```python
transformers.Wav2Vec2FeatureExtractor(feature_size = 1, sampling_rate = 16000, padding_value = 0.0, return_attention_mask = False, do_normalize = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L28)

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 1) : 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).

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

do_normalize (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar la entrada a media cero y varianza unitaria. La normalización puede ayudar a mejorar significativamente el rendimiento en algunos modelos, *por ejemplo*, [wav2vec2-lv60](https://huggingface.co/models?search=lv60).

return_attention_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si [__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) debe devolver `attention_mask`.    Los modelos Wav2Vec2 que tienen `config.feat_extract_norm == "group"` configurado, como [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **no** se han entrenado utilizando `attention_mask`. Para dichos modelos, `input_values` simplemente debe rellenarse con 0 y no se debe pasar `attention_mask`.  Para los modelos Wav2Vec2 que tienen `config.feat_extract_norm == "layer"` configurado, como [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), se debe pasar `attention_mask` para la inferencia por lotes.

Construye un extractor de características Wav2Vec2.

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.

#### __llamada__[[transformers.Wav2Vec2FeatureExtractor.__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_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L99)

**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 `False`) : 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)    Los modelos Wav2Vec2 que tienen `config.feat_extract_norm == "group"` configurado, como [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **no** se han entrenado utilizando `attention_mask`. Para dichos modelos, `input_values` simplemente debe rellenarse con 0 y no se debe pasar ninguna `attention_mask`.  Para los modelos Wav2Vec2 que tienen `config.feat_extract_norm == "layer"` configurado, como [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), se debe pasar `attention_mask` para la inferencia por lotes.

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

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

## Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

#### transformers.Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/processing_wav2vec2.py#L25)

**Parámetros:**

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

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

Crea un Wav2Vec2Processor que envuelve un extractor de características y un tokenizador en un único procesador.

[Wav2Vec2Processor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor) ofrece todas las funcionalidades de [Wav2Vec2FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) y [Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer). Consulte [~Wav2Vec2FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) y [~Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer) para obtener más información.

#### __llamada__[[transformers.Wav2Vec2Processor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | None = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

**Parámetros:**

audio (`Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : 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]]`, *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 de caracteres (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

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.

**Devuelve:**

Este método devuelve los resultados de cada método `call`. Si se utilizan ambos, la salida es un diccionario que contiene los resultados de ambos.

#### pad[[transformers.Wav2Vec2Processor.pad]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/processing_wav2vec2.py#L61)

**Parámetros:**

input_features : Cuando el primer argumento es un diccionario que contiene un lote de tensores, o cuando está presente el argumento `input_features`, se pasa a [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

labels : Cuando el argumento `label` está presente, se pasa a [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).

**Devuelve:**

Este método devuelve los resultados de cada método `pad`. Si se utilizan ambos, la salida es un diccionario que contiene los resultados de ambos.

Este método opera sobre lotes de características extraídas y/o texto tokenizado. Transmite todos los argumentos a [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) y/o [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) según la modalidad de entrada y devuelve sus salidas. Si se pasan ambas modalidades, se invocan [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) y [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).

#### from_pretrained[[transformers.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.

## Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

> [!WARNING]
> [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) y la decodificación con modelos de lenguaje n-gram mediante pyctcdecode + kenlm están en desuso y se eliminarán en Transformers v6. Requieren pyctcdecode y kenlm, que ya no se instalan con `transformers[audio]`. Para mantener la decodificación con modelos de lenguaje, llama a pyctcdecode directamente, consulta [Migrar a pyctcdecode](#migrating-to-pyctcdecode).

#### transformers.Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

```python
transformers.Wav2Vec2ProcessorWithLM(feature_extractor: FeatureExtractionMixin, tokenizer: PreTrainedTokenizerBase, decoder: BeamSearchDecoderCTC)
```

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

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

decoder (`BeamSearchDecoderCTC`) : Una instancia de `pyctcdecode.BeamSearchDecoderCTC`. El decodificador es una entrada obligatoria.

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

[Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) 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.Wav2Vec2ProcessorWithLM.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L219)

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

#### pad[[transformers.Wav2Vec2ProcessorWithLM.pad]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L244)

Cuando se utiliza en el modo normal, este método reenvía todos sus argumentos a `~FeatureExtractionMixin.pad` del extractor de características y devuelve su salida. Si se utiliza en el contexto `~Wav2Vec2ProcessorWithLM.as_target_processor`, este método reenvía todos sus argumentos a [pad()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) de Wav2Vec2CTCTokenizer. Consulte la docstring de los dos métodos anteriores para obtener más información.

#### from_pretrained[[transformers.Wav2Vec2ProcessorWithLM.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L112)

**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 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) como a [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)

Instancia un [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) a partir de un procesador Wav2Vec2 preentrenado.

Este método de clase simplemente llama a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) del extractor de características, a [from_pretrained()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained) de Wav2Vec2CTCTokenizer y a `pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub`.

Consulte los docstrings de los métodos anteriores para obtener más información.

#### save_pretrained[[transformers.Wav2Vec2ProcessorWithLM.save_pretrained]]

```python
save_pretrained(save_directory)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L108)

#### batch_decode[[transformers.Wav2Vec2ProcessorWithLM.batch_decode]]

```python
batch_decode(logits: ndarray, pool: multiprocessing.pool.Pool | None = None, num_processes: int | None = None, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L271)

**Parámetros:**

logits (`np.ndarray`) : El vector de logits de salida del modelo que representa las probabilidades logarítmicas para cada token.

pool (`multiprocessing.Pool`, *opcional*) : Un pool gestionado por el usuario, opcional. Si no se establece, se creará y cerrará automáticamente. El pool debe instanciarse *después* de `Wav2Vec2ProcessorWithLM`. De lo contrario, el LM no estará disponible para los subprocesos del pool.    Actualmente, solo se pueden utilizar pools creados con un contexto 'fork'. Si se pasa un pool 'spawn', se ignorará y se utilizará la decodificación secuencial en su lugar.

num_processes (`int`, *opcional*) : Si `pool` no está definido, número de procesos sobre los que la función debe paralelizarse. El valor predeterminado es el número de CPUs disponibles.

beam_width (`int`, *opcional*) : Número máximo de haces en cada paso de la decodificación. El valor predeterminado es DEFAULT_BEAM_WIDTH de pyctcdecode.

beam_prune_logp (`int`, *opcional*) : Los haces que sean mucho peores que el mejor haz se recortarán. El valor predeterminado es DEFAULT_PRUNE_LOGP de pyctcdecode.

token_min_logp (`int`, *opcional*) : Se omiten los tokens cuyo logp sea inferior a este valor, a menos que sean el argmax del frame. El valor predeterminado es DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.

hotwords (`list[str]`, *opcional*) : Lista de palabras con importancia adicional, pueden ser OOV para el LM

hotword_weight (`int`, *opcional*) : Factor de peso para la importancia de las palabras clave. Por defecto, se usa DEFAULT_HOTWORD_WEIGHT de pyctcdecode.

alpha (`float`, *opcional*) : Peso para el modelo de lenguaje durante la fusión superficial

beta (`float`, *opcional*) : Peso para el ajuste de la puntuación de longitud durante la puntuación

unk_score_offset (`float`, *opcional*) : Cantidad de desplazamiento de la puntuación de registro para tokens desconocidos

lm_score_boundary (`bool`, *opcional*) : Si kenlm debe respetar los límites al puntuar

output_word_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.

n_best (`int`, *opcional*, valor predeterminado `1`) : Número de mejores hipótesis a devolver. Si `n_best` es mayor que 1, el `text` devuelto será una lista de listas de cadenas, `logit_score` será una lista de listas de flotantes y `lm_score` será una lista de listas de flotantes, donde la longitud de la lista externa corresponderá al tamaño del lote y la longitud de la lista interna corresponderá al número de hipótesis devueltas. El valor debe ser >= 1. Consulte el ejemplo de [decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) para comprender mejor cómo utilizar `output_word_offsets`. [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) funciona de la misma manera con salidas por lotes.

**Devuelve:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Decodifica por lotes los logits de salida en transcripción de audio con soporte de modelo de lenguaje.

Esta función utiliza el módulo multiprocessing de Python. Actualmente, multiprocessing solo está disponible en sistemas Unix (consulte este [issue](https://github.com/kensho-technologies/pyctcdecode/issues/65)).

Si está decodificando varios lotes, considere crear un `Pool` y pasarlo a `batch_decode`. De lo contrario, `batch_decode` será muy lento, ya que creará un `Pool` nuevo para cada llamada. Consulte el ejemplo de uso a continuación.

Ejemplo: consulte [Decodificación de varios audios](#decoding-multiple-audios).

#### decode[[transformers.Wav2Vec2ProcessorWithLM.decode]]

```python
decode(logits: ndarray, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L456)

**Parámetros:**

logits (`np.ndarray`) : El vector de logits de salida del modelo que representa las probabilidades logarítmicas para cada token.

beam_width (`int`, *opcional*) : Número máximo de haces en cada paso de la decodificación. El valor predeterminado es DEFAULT_BEAM_WIDTH de pyctcdecode.

beam_prune_logp (`int`, *opcional*) : Umbral para podar haces con log-probs menores que best_beam_logp + beam_prune_logp. El valor debe ser <= 0. El valor predeterminado es DEFAULT_PRUNE_LOGP de pyctcdecode.

token_min_logp (`int`, *opcional*) : Se omiten los tokens con log-probs por debajo de token_min_logp, a menos que tengan el log-prob máximo para una enunciación. El valor predeterminado es DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.

hotwords (`list[str]`, *opcional*) : Lista de palabras con importancia adicional que pueden faltar en el vocabulario del LM, p. ej. ["huggingface"]

hotword_weight (`int`, *opcional*) : Multiplicador de peso que aumenta las puntuaciones de las palabras clave. El valor predeterminado es DEFAULT_HOTWORD_WEIGHT de pyctcdecode.

alpha (`float`, *opcional*) : Peso para el modelo de lenguaje durante la fusión superficial

beta (`float`, *opcional*) : Peso para el ajuste de la puntuación de longitud durante la puntuación

unk_score_offset (`float`, *opcional*) : Cantidad de desplazamiento de la puntuación de registro para tokens desconocidos

lm_score_boundary (`bool`, *opcional*) : Si kenlm debe respetar los límites al puntuar

output_word_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de las palabras. Los desplazamientos de las palabras pueden usarse en combinación con la tasa de muestreo y la tasa de submuestreo del modelo para calcular las marcas de tiempo de las palabras transcritas.

n_best (`int`, *opcional*, valor predeterminado `1`) : Número de mejores hipótesis a devolver. Si `n_best` es mayor que 1, el `text` devuelto será una lista de cadenas, `logit_score` será una lista de flotantes y `lm_score` será una lista de flotantes, donde la longitud de estas listas corresponderá al número de hipótesis devueltas. El valor debe ser >= 1.    Consulte el siguiente ejemplo para comprender mejor cómo utilizar `output_word_offsets`.

**Devuelve:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Decodifica los logits de salida a una transcripción de audio con soporte de modelo de lenguaje.

Ejemplo:

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
...     logits = model(input_values).logits[0].cpu().numpy()

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
```

### Decodificación de varios audios

> [!WARNING]
> Este ejemplo utiliza el [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) obsoleto. Para el nuevo código, pase un `multiprocessing.Pool` a `decode_beams_batch` de pyctcdecode en su lugar, consulte [Migrar a pyctcdecode](#migrating-to-pyctcdecode).

Si planeas decodificar varios lotes de audios, debes considerar usar [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) y pasar una instancia de `multiprocessing.Pool`. De lo contrario, el rendimiento de [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) será más lento que llamar a [decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) para cada audio individualmente, ya que internamente instancia un nuevo `Pool` para cada llamada. Consulta el siguiente ejemplo:

```python
# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context

import datasets
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor

# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))

def map_to_array(example):
    example["speech"] = example["audio"]["array"]
    return example

# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])

def map_to_pred(batch, pool):
    inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

    with torch.no_grad():
        logits = model(**inputs).logits

    transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
    batch["transcription"] = transcription
    return batch

# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
#       otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
    result = dataset.map(
        map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
    )

result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
```

### Migrar a pyctcdecode

[Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) es un envoltorio ligero de [pyctcdecode](https://github.com/kensho-technologies/pyctcdecode). Cargue el extractor de características y el tokenizador con [Wav2Vec2Processor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor), cargue el modelo de lenguaje con pyctcdecode y llame a pyctcdecode sobre los logits. Esto produce las mismas transcripciones que [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode). Requiere [pyctcdecode](https://github.com/kensho-technologies/pyctcdecode) y [kenlm](https://github.com/kpu/kenlm), que ya no se instalan con `transformers[audio]`.

```python
import torch
from pyctcdecode import BeamSearchDecoderCTC

from transformers import AutoModelForCTC, Wav2Vec2Processor

repo = "patrickvonplaten/wav2vec2-base-100h-with-lm"
model = AutoModelForCTC.from_pretrained(repo)
processor = Wav2Vec2Processor.from_pretrained(repo)  # feature extractor + tokenizer
# only download the language model and the alphabet, not the model weights
decoder = BeamSearchDecoderCTC.load_from_hf_hub(repo, allow_patterns=["language_model/*", "alphabet.json"])

inputs = processor(audio, sampling_rate=16_000, padding=True, return_tensors="pt")
with torch.no_grad():
    logits = model(**inputs).logits.cpu().numpy()

# was: processor_with_lm.batch_decode(logits, alpha=0.5, beta=1.0, beam_width=50).text

# `alpha`, `beta`, `unk_score_offset` and `lm_score_boundary` are set on the decoder (values that are not passed are kept)
decoder.reset_params(alpha=0.5, beta=1.0)

# drop the frames padded with -100, as `batch_decode` does
logits_list = [sample[(sample != -100.0).all(axis=-1)] for sample in logits]

# `beam_width`, `beam_prune_logp`, `token_min_logp`, `hotwords` and `hotword_weight` are decoding arguments
beams = decoder.decode_beams_batch(None, logits_list, beam_width=50)
transcription = [sample_beams[0][0] for sample_beams in beams]
```

- **Muestra única**: `processor_with_lm.decode(logits[0]).text` se convierte en `decoder.decode_beams(logits[0])[0][0]`.
- **Use `decode_beams` / `decode_beams_batch`**, not `decode` / `decode_batch`: the latter prune the beam history and can give different transcriptions.
- **Decodificación paralela**: pase una `multiprocessing.Pool` creada con un contexto `fork` como primer argumento de `decode_beams_batch`.
- Los **Beams** se ordenan de mejor a peor y también incluyen las puntuaciones y los desplazamientos de palabras:
  - `decode_beams_batch`: `(text, word_offsets, logit_score, lm_score)`;
  - `decode_beams`: `(text, last_lm_state, word_offsets, logit_score, lm_score)`.

Para decodificar sin el modelo de lenguaje, tome el token más probable en cada fotograma:

```python
transcription = processor.batch_decode(logits.argmax(-1))
```

## Salidas específicas de Wav2Vec2[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

#### transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

```python
transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput(text: list[list[str]] | list[str] | str, logit_score: list[list[float]] | list[float] | float = None, lm_score: list[list[float]] | list[float] | float = None, word_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L46)

**Parámetros:**

text (lista de `str` o `str`) : Logits decodificados en texto. Normalmente, la transcripción del habla.

logit_score (lista de `float` o `float`) : Puntuación total de logit de los haces asociados con el texto generado.

lm_score (lista de `float`) : lm_score fusionado de los beams asociados con el texto generado.

word_offsets (lista de `list[dict[str, Union[int, str]]]` o `list[dict[str, Union[int, str]]]`) : Desplazamientos de las palabras decodificadas. En combinación con la tasa de muestreo y la tasa de submuestreo del modelo, los desplazamientos de las palabras se pueden utilizar para calcular marcas de tiempo para cada palabra.

Tipo de salida de [decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) y [batch_decode()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode). Obsoleto, se eliminará en Transformers v6.

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

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

**Parámetros:**

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.

extract_features (`torch.Tensor` de forma `(batch_size, sequence_length, conv_dim[-1])`) : Secuencia de vectores de características extraídos de la última capa convolucional del modelo.

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 + 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 de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para modelos que han sido entrenados con el objetivo de pérdida de Wav2Vec2.

#### transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput[[transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput]]

```python
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, contrastive_loss: typing.Optional[torch.Tensor] = None, diversity_loss: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L76)

**Parámetros:**

loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : Pérdida total como la suma de la pérdida contrastiva (L_m) y la pérdida de diversidad (L_d), tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).

projected_states (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) : Estados ocultos del modelo proyectados a *config.proj_codevector_dim* que pueden utilizarse para predecir los estados cuantizados proyectados enmascarados.

projected_quantized_states (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) : Vectores de características extraídas cuantizadas y proyectados a *config.proj_codevector_dim* que representan los vectores objetivo positivos para la pérdida contrastiva.

codevector_perplexity (`torch.Tensor` de forma `(1,)`) : La perplejidad de la distribución de codevector, utilizada para medir la diversidad del codebook.

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` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 de embedding iniciales opcionales.

attentions (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

contrastive_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : La pérdida contrastiva (L_m) tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).

diversity_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : La pérdida de diversidad (L_d) tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).

Tipo de salida de [Wav2Vec2ForPreTraining](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining), con posibles estados ocultos y atenciones.

## Wav2Vec2Model[[transformers.Wav2Vec2Model]]

#### transformers.Wav2Vec2Model[[transformers.Wav2Vec2Model]]

```python
transformers.Wav2Vec2Model(config: Wav2Vec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1197)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 básico que genera estados ocultos sin ninguna cabeza específica 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.Wav2Vec2Model.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1271)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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)

mask_time_indices (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices para enmascarar las características extraídas para la pérdida contrastiva. En modo de entrenamiento, el modelo aprende a predecir las características extraídas enmascaradas en el espacio *config.proj_codevector_dim*.

**Devuelve:** [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) o `tuple(torch.Tensor)`

Un [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) 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 ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) y las entradas.

El método forward de [Wav2Vec2Model](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Model) 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.
- **extract_features** (`torch.Tensor` de forma `(batch_size, sequence_length, conv_dim[-1])`) -- Secuencia de vectores de características extraídos de la última capa convolucional del modelo.
- **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 + 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 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.

## Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

#### transformers.Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

```python
transformers.Wav2Vec2ForCTC(config: Wav2Vec2Config, target_lang: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1525)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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.

target_lang (`str`, *opcional*) : Idioma de los pesos del adaptador. Los pesos del adaptador se almacenan en el formato adapter..safetensors o adapter..bin. Solo es relevante al usar una instancia de [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) con adaptadores. Usa 'eng' de forma predeterminada.

Modelo Wav2Vec2 con una cabeza de `language modeling` en la parte superior para la clasificación temporal conexionista (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.Wav2Vec2ForCTC.forward]]

```python
forward(input_values: typing.Optional[torch.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/wav2vec2/modeling_wav2vec2.py#L1594)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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.LongTensor` de forma `(batch_size, target_length)`, *opcional*) : Etiquetas para la clasificación temporal conexionista. Tenga en cuenta que `target_length` debe ser menor o igual que la longitud de la secuencia de los logits de salida. Los índices se seleccionan en `[-100, 0, ..., config.vocab_size - 1]`. Todas las etiquetas establecidas en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para las etiquetas en `[0, ..., config.vocab_size - 1]`.

**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 ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) y las entradas.

El método forward de [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) 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 (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, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### load_adapter[[transformers.Wav2Vec2ForCTC.load_adapter]]

```python
load_adapter(target_lang: str, force_load = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1020)

**Parámetros:**

target_lang (`str`) : Debe ser un id de idioma de un peso de adaptador existente. Los pesos de adaptador se almacenan en el formato adapter..safetensors o adapter..bin

force_load (`bool`, por defecto `True`) : Indica si las ponderaciones deben cargarse incluso si `target_lang` coincide con `self.target_lang`.

cache_dir (`Union[str, os.PathLike]`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché la configuración de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Los proxies se utilizan en cada solicitud.

local_files_only(`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben buscar únicamente archivos locales (es decir, no intentar descargar el modelo).

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.    Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

mirror (`str`, *opcional*) : Origen de espejo para acelerar las descargas en China. Si resides en China y tienes problemas de acceso, puedes establecer esta opción para resolverlos. Ten en cuenta que no garantizamos la oportunidad ni la seguridad. Consulta el sitio de espejo para obtener más información.

Cargue un modelo de adaptador de lenguaje desde un modelo de adaptador preentrenado.

Active el modo especial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) para usar este método en un entorno con cortafuegos.

Ejemplos:

```python
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor

>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")
```

## Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

#### transformers.Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

```python
transformers.Wav2Vec2ForSequenceClassification(config: Wav2Vec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1652)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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.

Modelo Wav2Vec2 con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada) para tareas como el Keyword Spotting de SUPERB.

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

```python
forward(input_values: typing.Optional[torch.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/wav2vec2/modeling_wav2vec2.py#L1685)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada).

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

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

El método forward de [Wav2Vec2ForSequenceClassification](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification) 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 clasificación (o de regresión si config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Puntuaciones de clasificación (o de regresión si config.num_labels==1) (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 de clasificación de una sola etiqueta:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Ejemplo de clasificación multietiqueta:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

#### transformers.Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

```python
transformers.Wav2Vec2ForAudioFrameClassification(config: Wav2Vec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1745)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 con una cabeza de clasificación de tramos en la parte superior para tareas como la diarización de hablantes.

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

```python
forward(input_values: typing.Optional[torch.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/wav2vec2/modeling_wav2vec2.py#L1777)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada).

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

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

El método forward de [Wav2Vec2ForAudioFrameClassification](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForAudioFrameClassification) 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 clasificación.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Puntuaciones de clasificación (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 AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...
```

## Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

#### transformers.Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

```python
transformers.Wav2Vec2ForXVector(config: Wav2Vec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1893)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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.

Modelo Wav2Vec2 con una cabeza de extracción de características XVector en la parte superior para tareas como la Verificación de Orador.

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

```python
forward(input_values: typing.Optional[torch.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/wav2vec2/modeling_wav2vec2.py#L1943)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada).

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

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

El método forward de [Wav2Vec2ForXVector](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector) 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 clasificación.
- **logits** (`torch.Tensor` de forma `(batch_size, config.xvector_output_dim)`) -- Estados ocultos de clasificación antes de AMSoftmax.
- **embeddings** (`torch.Tensor` de forma `(batch_size, config.xvector_output_dim)`) -- Embeddings de las frases utilizados para la recuperación basada en similitud de vectores.
- **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 + 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 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 AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...
```

## Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

#### transformers.Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

```python
transformers.Wav2Vec2ForPreTraining(config: Wav2Vec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1322)

**Parámetros:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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.

Modelo Wav2Vec2 con un cuantizador y una cabeza `VQ` 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.Wav2Vec2ForPreTraining.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1370)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

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)

mask_time_indices (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices para enmascarar las características extraídas para la pérdida contrastiva. En modo de entrenamiento, el modelo aprende a predecir las características extraídas enmascaradas en el espacio *config.proj_codevector_dim*.

sampled_negative_indices (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_negatives)`, *opcional*) : Índices que indican qué vectores objetivo cuantizados se utilizan como vectores negativos muestreados en la pérdida contrastiva. Entrada obligatoria para el preentrenamiento.

**Devuelve:** [Wav2Vec2ForPreTrainingOutput](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) o `tuple(torch.Tensor)`

Un [Wav2Vec2ForPreTrainingOutput](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) 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 ([Wav2Vec2Config](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Config)) y las entradas.

El método forward de [Wav2Vec2ForPreTraining](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining) 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** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- Pérdida total como la suma de la pérdida contrastiva (L_m) y la pérdida de diversidad (L_d), tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).
- **projected_states** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Estados ocultos del modelo proyectados a *config.proj_codevector_dim* que pueden utilizarse para predecir los estados cuantizados proyectados enmascarados.
- **projected_quantized_states** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Vectores de características extraídas cuantizadas proyectados a *config.proj_codevector_dim* que representan los vectores objetivo positivos para la pérdida contrastiva.
- **codevector_perplexity** (`torch.Tensor` de forma `(1,)`) -- La perplejidad de la distribución de codevector, utilizada para medir la diversidad del codebook.
- **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 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 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.
- **contrastive_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- La pérdida contrastiva (L_m) tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).
- **diversity_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- La pérdida de diversidad (L_d) tal como se indica en el [artículo oficial](https://huggingface.co/papers/2006.11477).

Ejemplo:

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
```

