# UniSpeech-SAT

## Resumen

El modelo UniSpeech-SAT fue propuesto en [UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware Pre-Training](https://huggingface.co/papers/2110.05752) por Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.

El resumen del artículo es el siguiente:

*El aprendizaje auto-supervisado (SSL) es un objetivo de larga data en el procesamiento del habla, ya que aprovecha datos no etiquetados a gran escala y evita la anotación humana extensiva. En los últimos años se han logrado grandes éxitos al aplicar el aprendizaje auto-supervisado en el reconocimiento del habla, mientras que se ha realizado una exploración limitada en la aplicación de SSL para modelar las características del hablante. En este artículo, nos proponemos mejorar el marco de SSL existente para el aprendizaje de representaciones del hablante. Se introducen dos métodos para mejorar la extracción no supervisada de información del hablante. En primer lugar, aplicamos el aprendizaje multitarea al marco de SSL actual, donde integramos la pérdida contrastiva por enunciado con la función objetivo de SSL. En segundo lugar, para una mejor discriminación del hablante, proponemos una estrategia de mezcla de enunciados para el aumento de datos, donde se crean enunciados superpuestos adicionales de manera no supervisada y se incorporan durante el entrenamiento. Integramos los métodos propuestos en el marco de HuBERT. Los resultados experimentales en el benchmark SUPERB muestran que el sistema propuesto logra un rendimiento de última generación en el aprendizaje de representaciones universales, especialmente para tareas orientadas a la identificación del hablante. Se realiza un estudio de ablación que verifica la eficacia de cada método propuesto. Finalmente, escalamos el conjunto de datos de entrenamiento a 94 mil horas de datos de audio públicos y logramos una mejora adicional en el rendimiento en todas las tareas de SUPERB.*

Este modelo fue aportado por [patrickvonplaten](https://huggingface.co/patrickvonplaten). El código de los autores se puede encontrar [aquí](https://github.com/microsoft/UniSpeech/tree/main/UniSpeech-SAT).

## Consejos de uso

- UniSpeechSat es un modelo de voz que acepta un array de flotantes correspondiente a la forma de onda cruda de la señal de voz. Utilice [Wav2Vec2Processor](/docs/transformers/main/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor) para la extracción de características.
- El modelo UniSpeechSat se puede ajustar con clasificación temporal conexionista (CTC), por lo que la salida del modelo debe decodificarse con [Wav2Vec2CTCTokenizer](/docs/transformers/main/es/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).
- UniSpeechSat rinde especialmente bien en tareas de verificación de hablantes, identificación de hablantes y diarización de hablantes.

## Recursos

- [Guía de la tarea de clasificación de audio](../tasks/audio_classification)
- [Guía de la tarea de reconocimiento automático del habla](../tasks/asr)

## UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

#### transformers.UniSpeechSatConfig[[transformers.UniSpeechSatConfig]]

```python
transformers.UniSpeechSatConfig(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 = 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 = 'mean', 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 = 0, bos_token_id: int = 1, eos_token_id: int = 2, num_clusters: int = 504)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/configuration_unispeech_sat.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 [UniSpeechSatForCTC](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

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, 2, 2)`) : 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_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_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 `mean`) : Especifica la reducción que se debe aplicar a la salida de `torch.nn.CTCLoss`. Solo es relevante durante el entrenamiento.

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 [UniSpeechSatForCTC](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC).

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 [UniSpeechSatForSequenceClassification](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification).

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 (`int`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el fin de la secuencia en el vocabulario.

num_clusters (`int`, *opcional*, valor predeterminado 504) : Número de clústeres para la etiquetación débil. Solo es relevante al usar una instancia de [UniSpeechSatForPreTraining](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining).

Esta es la clase de configuración para almacenar la configuración de un modelo Unispeech Sat. Se utiliza para instanciar un modelo Unispeech Sat 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 [microsoft/unispeech-sat-base-100h-libri-ft](https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft)

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

Ejemplo:

```python
>>> from transformers import UniSpeechSatModel, UniSpeechSatConfig

>>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> configuration = UniSpeechSatConfig()

>>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> model = UniSpeechSatModel(configuration)

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

## Salidas específicas de UniSpeechSat[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

#### transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput[[transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput]]

```python
transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, logits: 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L65)

**Parámetros:**

loss (`*optional*`, returned when model is in train mode, `torch.Tensor` of shape `(1,)`) : Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`, *opcional*) : Puntuaciones de predicción del modelo de pérdida contrastiva, es decir, la salida del modelo antes del softmax final.

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.

Tipo de salida de `UniSpeechSatForPreTrainingOutput`, con estados ocultos y atenciones potenciales.

## UniSpeechSatModel[[transformers.UniSpeechSatModel]]

#### transformers.UniSpeechSatModel[[transformers.UniSpeechSatModel]]

```python
transformers.UniSpeechSatModel(config: UniSpeechSatConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L880)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Unispeech Sat básico que emite estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.UniSpeechSatModel.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/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L943)

**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/main/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/main/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/main/es/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) o `tuple(torch.Tensor)`

Un [Wav2Vec2BaseModelOutput](/docs/transformers/main/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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatModel](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatModel) 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.

## UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

#### transformers.UniSpeechSatForCTC[[transformers.UniSpeechSatForCTC]]

```python
transformers.UniSpeechSatForCTC(config: UniSpeechSatConfig, target_lang: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1095)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/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 [UniSpeechSatForCTC](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) con adaptadores. Usa 'eng' de forma predeterminada.

Modelo UniSpeechSat con una cabeza de `language modeling` en la parte superior para Connectionist Temporal Classification (CTC).

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.UniSpeechSatForCTC.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/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1164)

**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/main/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/main/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/main/es/main_classes/output#transformers.modeling_outputs.CausalLMOutput) o `tuple(torch.Tensor)`

Un [CausalLMOutput](/docs/transformers/main/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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatForCTC](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) 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, UniSpeechSatForCTC
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForCTC.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

#### transformers.UniSpeechSatForSequenceClassification[[transformers.UniSpeechSatForSequenceClassification]]

```python
transformers.UniSpeechSatForSequenceClassification(config: UniSpeechSatConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1222)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo UniSpeechSat con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada) para tareas como el reconocimiento de palabras clave de SUPERB.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.UniSpeechSatForSequenceClassification.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/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1255)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio crudo 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/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte `UniSpeechSatProcessor.__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/main/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) o `tuple(torch.Tensor)`

Un [SequenceClassifierOutput](/docs/transformers/main/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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatForSequenceClassification](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForSequenceClassification) 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 (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, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

>>> 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 = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", 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, UniSpeechSatForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft", 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 = UniSpeechSatForSequenceClassification.from_pretrained(
...     "microsoft/unispeech-sat-base-100h-libri-ft", 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
```

## UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

#### transformers.UniSpeechSatForAudioFrameClassification[[transformers.UniSpeechSatForAudioFrameClassification]]

```python
transformers.UniSpeechSatForAudioFrameClassification(config: UniSpeechSatConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1315)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Unispeech Sat con una cabeza de clasificación de marcos en la parte superior para tareas como la diarización de hablantes.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.UniSpeechSatForAudioFrameClassification.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/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1347)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio crudo 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/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte `UniSpeechSatProcessor.__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/main/es/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) o `tuple(torch.Tensor)`

Un [TokenClassifierOutput](/docs/transformers/main/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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatForAudioFrameClassification](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForAudioFrameClassification) 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, 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, UniSpeechSatForAudioFrameClassification
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForAudioFrameClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

#### transformers.UniSpeechSatForXVector[[transformers.UniSpeechSatForXVector]]

```python
transformers.UniSpeechSatForXVector(config: UniSpeechSatConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1461)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo UniSpeechSat 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/main/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.UniSpeechSatForXVector.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/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1511)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores flotantes de la forma de onda de audio crudo 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/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte `UniSpeechSatProcessor.__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/main/es/main_classes/output#transformers.modeling_outputs.XVectorOutput) o `tuple(torch.Tensor)`

Un [XVectorOutput](/docs/transformers/main/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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatForXVector](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForXVector) 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, UniSpeechSatForXVector
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForXVector.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")

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

## UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

#### transformers.UniSpeechSatForPreTraining[[transformers.UniSpeechSatForPreTraining]]

```python
transformers.UniSpeechSatForPreTraining(config: UniSpeechSatConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L989)

**Parámetros:**

config ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo UniSpeechSat con un módulo de cuantización vectorial y pérdida ctc para el preentrenamiento.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.UniSpeechSatForPreTraining.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unispeech_sat/modeling_unispeech_sat.py#L1045)

**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/main/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/main/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)

**Devuelve:** [UniSpeechSatForPreTrainingOutput](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) o `tuple(torch.Tensor)`

Un [UniSpeechSatForPreTrainingOutput](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput) 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 ([UniSpeechSatConfig](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatConfig)) y las entradas.

El método forward de [UniSpeechSatForPreTraining](/docs/transformers/main/es/model_doc/unispeech-sat#transformers.UniSpeechSatForPreTraining) 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 model is in train mode, `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).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.proj_codevector_dim)`, *opcional*) -- Puntuaciones de predicción del modelo de pérdida contrastiva, es decir, la salida del modelo antes del softmax final.
- **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.

Ejemplo:

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
>>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
>>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
>>> # TODO: Add full pretraining example
```