# HuBERT

[HuBERT](https://huggingface.co/papers/2106.07447) es un modelo de voz auto-supervisado que agrupa etiquetas objetivo alineadas para una pérdida de predicción similar a la de BERT y aplica la pérdida de predicción solo sobre las regiones enmascaradas, lo que obliga al modelo a aprender tanto modelado acústico como lingüístico sobre entradas continuas. Aborda los desafíos de múltiples unidades de sonido por enunciado, la ausencia de un léxico durante el preentrenamiento y las unidades de sonido de longitud variable sin segmentación explícita.

Puedes encontrar todos los puntos de control originales de HuBERT en la colección [HuBERT](https://huggingface.co/collections/facebook/hubert-651fca95d57549832161e6b6).

> [!TIP]
> Este modelo fue aportado por [patrickvonplaten](https://huggingface.co/patrickvonplaten).
>
> Haz clic en los modelos de HuBERT en la barra lateral derecha para ver más ejemplos de cómo aplicar HuBERT a diferentes tareas de audio.

El siguiente ejemplo demuestra cómo transcribir automáticamente el habla en texto con [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline) o la clase [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipeline = pipeline(
    task="automatic-speech-recognition",
    model="facebook/hubert-large-ls960-ft",
    device=0
)

pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
```

```python
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor

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

processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")
model = AutoModelForCTC.from_pretrained("facebook/hubert-base-ls960", device_map="auto", attn_implementation="sdpa")

inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt").to(model.device)
with torch.no_grad():
    logits = model(**inputs).logits
predicted_ids = torch.argmax(logits, dim=-1)

transcription = processor.batch_decode(predicted_ids)
print(transcription[0])
```

## Cuantización

La cuantización reduce la carga de memoria de los modelos grandes al representar los pesos con una precisión inferior. Consulte el resumen de [Cuantización](../quantization/overview) para conocer más backends de cuantización disponibles.

El ejemplo siguiente utiliza [bitsandbytes](../quantization/bitsandbytes) para cuantizar los pesos a 4 bits.

```python
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0
)

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

processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")
model = AutoModelForCTC.from_pretrained("facebook/hubert-base-ls960", quantization_config=bnb_config, device_map="auto", attn_implementation="sdpa")

inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt").to(model.device)
with torch.no_grad():
    logits = model(**inputs).logits
predicted_ids = torch.argmax(logits, dim=-1)

transcription = processor.batch_decode(predicted_ids)
print(transcription[0])
```

## Notas

- Los modelos HuBERT esperan una entrada de audio en bruto como un array de float de 1D muestreado a 16 kHz.

## HubertConfig[[transformers.HubertConfig]]

#### transformers.HubertConfig[[transformers.HubertConfig]]

```python
transformers.HubertConfig(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_layer_norm: bool = True, feat_proj_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, conv_pos_batch_norm: bool = False, 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, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/hubert/configuration_hubert.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_layer_norm (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar LayerNorm a la salida del codificador de características.

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

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]`, *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]`, *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]`, *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.

conv_pos_batch_norm (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar batch norm en lugar de weight norm en conv_pos

do_stable_layer_norm (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar 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''

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

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

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

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

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.

Esta es la clase de configuración para almacenar la configuración de un HubertModel. Se utiliza para instanciar un modelo Hubert 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/hubert-base-ls960](https://huggingface.co/facebook/hubert-base-ls960)

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 HubertModel, HubertConfig

>>> # Initializing a Hubert facebook/hubert-base-ls960 style configuration
>>> configuration = HubertConfig()

>>> # Initializing a model from the facebook/hubert-base-ls960 style configuration
>>> model = HubertModel(configuration)

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

## HubertModel[[transformers.HubertModel]]

#### transformers.HubertModel[[transformers.HubertModel]]

```python
transformers.HubertModel(config: HubertConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/hubert/modeling_hubert.py#L760)

**Parámetros:**

config ([HubertConfig](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertConfig)) : 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 Hubert básico que emite estados ocultos sin ningún cabezal específico en la parte superior.

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

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

#### forward[[transformers.HubertModel.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/hubert/modeling_hubert.py#L825)

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

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

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

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

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

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft")

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

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

>>> input_values = processor(ds["speech"][0], return_tensors="pt").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state
```

## HubertForCTC[[transformers.HubertForCTC]]

#### transformers.HubertForCTC[[transformers.HubertForCTC]]

```python
transformers.HubertForCTC(config: HubertConfig, target_lang: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/hubert/modeling_hubert.py#L905)

**Parámetros:**

config ([HubertConfig](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertConfig)) : 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 [HubertForCTC](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertForCTC) con adaptadores. Usa 'eng' de forma predeterminada.

Modelo Hubert con una cabeza de `language modeling` en la parte superior para Connectionist Temporal Classification (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.HubertForCTC.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/hubert/modeling_hubert.py#L974)

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

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

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

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

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

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

Ejemplo:

```python
>>> from transformers import AutoProcessor, HubertForCTC
>>> 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/hubert-base-ls960")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-base-ls960")

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

## HubertForSequenceClassification[[transformers.HubertForSequenceClassification]]

#### transformers.HubertForSequenceClassification[[transformers.HubertForSequenceClassification]]

```python
transformers.HubertForSequenceClassification(config: HubertConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/hubert/modeling_hubert.py#L1032)

**Parámetros:**

config ([HubertConfig](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertConfig)) : 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 Hubert 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.HubertForSequenceClassification.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/hubert/modeling_hubert.py#L1065)

**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/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte `HubertProcessor.__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 ([HubertConfig](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertConfig)) y las entradas.

El método forward de [HubertForSequenceClassification](/docs/transformers/v5.23.0/es/model_doc/hubert#transformers.HubertForSequenceClassification) 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, HubertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960")

>>> 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 = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", 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, HubertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", 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 = HubertForSequenceClassification.from_pretrained(
...     "facebook/hubert-base-ls960", 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
```

