# Whisper

[Whisper](https://huggingface.co/papers/2212.04356) es un transformer codificador-decodificador (secuencia a secuencia) preentrenado con 680.000 horas de datos de audio etiquetados. Esta cantidad de datos de preentrenamiento permite un rendimiento zero-shot en tareas de audio en inglés y en muchos otros idiomas. El decodificador permite que Whisper mapee las representaciones del habla aprendidas por el codificador a salidas útiles, como texto, sin necesidad de un ajuste fino adicional. Whisper funciona directamente sin configuración adicional.

Puedes encontrar todos los puntos de control originales de Whisper en la colección [Whisper](https://huggingface.co/collections/openai/whisper-release-6501bba2cf999715fd953013).

> [!TIP]
> Haz clic en los modelos de Whisper en la barra lateral derecha para ver más ejemplos de cómo aplicar Whisper a diferentes tareas de audio.
>
> Establezca `use_kernels=True` en [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para reemplazar las capas compatibles con kernels optimizados del Hub. Consulte [Carga de kernels](../kernel_doc/loading_kernels) para obtener más información.

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="openai/whisper-large-v3-turbo",
    device=0
)
pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
```

```python
# pip install datasets
from datasets import load_dataset

from transformers import AutoProcessor, WhisperForConditionalGeneration

processor = AutoProcessor.from_pretrained(
    "openai/whisper-large-v3-turbo",
)
model = WhisperForConditionalGeneration.from_pretrained(
    "openai/whisper-large-v3-turbo",
    device_map="auto",
    attn_implementation="sdpa"
)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio_sample = ds[0]["audio"]

input_features = processor(
    audio_sample["array"],
    sampling_rate=audio_sample["sampling_rate"],
    return_tensors="pt"
).input_features
input_features = input_features.to(model.device, dtype=model.dtype)

predicted_ids = model.generate(input_features, cache_implementation="static")
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
transcription[0]
```

## Notas

- Whisper se basa en un `generate` personalizado para la inferencia, asegúrate de consultar la documentación a continuación.
- El [WhisperProcessor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperProcessor) se puede utilizar para preparar el audio y decodificar los ids predichos de vuelta en texto.

## WhisperConfig[[transformers.WhisperConfig]]

#### transformers.WhisperConfig[[transformers.WhisperConfig]]

```python
transformers.WhisperConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 51865, num_mel_bins: int = 80, encoder_layers: int = 4, encoder_attention_heads: int = 6, decoder_layers: int = 4, decoder_attention_heads: int = 6, decoder_ffn_dim: int = 1536, encoder_ffn_dim: int = 1536, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, decoder_start_token_id: int = 50257, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 384, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, scale_embedding: bool = False, max_source_positions: int = 1500, max_target_positions: int = 448, pad_token_id: int | None = 50256, bos_token_id: int | None = 50256, eos_token_id: int | list[int] | None = 50256, suppress_tokens: list | None = None, begin_suppress_tokens: list[int] | tuple[int, ...] | None = (220, 50256), use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, apply_spec_augment: bool = False, 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, median_filter_width: int = 7, tie_word_embeddings: bool = True)
```

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

**Parámetros:**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

suppress_tokens (`list[int]`, *opcional*) : Una lista que contiene los tokens no de voz que se utilizarán en el procesador de logits de la función `generate`. NON_SPEECH_TOKENS y NON_SPEECH_TOKENS_MULTI corresponden al modelo `english-only` y al modelo `multilingual`, respectivamente.

begin_suppress_tokens (`list[int]`, *opcional*, valor predeterminado `[220,50256]`) : Una lista que contiene los tokens que se suprimirán al inicio del proceso de muestreo. Se inicializa con el token de `" "` (`blank_token_id`) y el `eos_token_id`

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

classifier_proj_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de la proyección antes del token mean-pooling para clasificación. Solo es relevante al usar una instancia de [WhisperForAudioClassification](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperForAudioClassification).

apply_spec_augment (`bool`, *opcional*, valor predeterminado `False`) : 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 == 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`.

median_filter_width (`int`, *opcional*, valor predeterminado 7) : Ancho del filtro mediano utilizado para suavizar las salidas de la atención cruzada al calcular las marcas de tiempo de los tokens. Debe ser un número impar.

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

Esta es la clase de configuración para almacenar la configuración de un WhisperModel. Se utiliza para instanciar un modelo Whisper 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 [openai/whisper-tiny](https://huggingface.co/openai/whisper-tiny)

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 WhisperConfig, WhisperModel

>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()

>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)

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

## WhisperTokenizer[[transformers.WhisperTokenizer]]

#### transformers.WhisperTokenizer[[transformers.WhisperTokenizer]]

```python
transformers.WhisperTokenizer(vocab: str | dict[str, int] | None = None, merges = None, normalizer_file = None, unk_token = '<|endoftext|>', bos_token = '<|endoftext|>', eos_token = '<|endoftext|>', add_prefix_space = False, language = None, task = None, predict_timestamps = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L163)

**Parámetros:**

vocab_file (`str`, *opcional*) : Ruta al archivo de vocabulario.

merges_file (`str`, *opcional*) : Ruta al archivo de fusiones.

normalizer_file (`str`, *opcional*) : Ruta al archivo normalizer_file.

tokenizer_file (`str`, *opcional*) : Ruta al archivo de [tokenizers](https://github.com/huggingface/tokenizers) (generalmente con extensión .json) que contiene todo lo necesario para cargar el tokenizador.

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

bos_token (`str`, *opcional*, valor predeterminado `"<|endoftext|>"`) : El token de inicio de secuencia. `decoder_start_token_id` se utiliza para establecer el primer token como `"<|startoftranscript|>"` durante la generación.

eos_token (`str`, *opcional*, valor predeterminado `"<|endoftext|>"`) : El token de fin de secuencia.

add_prefix_space (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial igual que cualquier otra palabra. (El tokenizador de Whisper detecta el inicio de las palabras mediante el espacio que las precede).

language (`str`, *opcional*) : El idioma del texto de la transcripción. El token de id de idioma correspondiente se añade al inicio de la secuencia para tareas de reconocimiento de voz y traducción de voz multilingües, p. ej. para el español se añade el token `"<|es|>"` al inicio de la secuencia. Esto debe usarse únicamente para el ajuste fino multilingüe.

task (`str`, *opcional*) : Identificador de tarea que se añadirá al inicio de la secuencia (si lo hay). Debe usarse para el ajuste fino multilingüe, con `"transcribe"` para el reconocimiento de voz y `"translate"` para la traducción de voz.

predict_timestamps (`bool`, *opcional*, valor predeterminado `False`) : Si se debe omitir el token `<|notimestamps|>` al inicio de la secuencia.

Construir un tokenizador de Whisper "rápido" (respaldado por la biblioteca *tokenizers* de HuggingFace).

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

#### set_prefix_tokens[[transformers.WhisperTokenizer.set_prefix_tokens]]

```python
set_prefix_tokens(language: str | None = None, task: str | None = None, predict_timestamps: bool | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L585)

**Parámetros:**

language (`str`, *opcional*, valor predeterminado `None`) : El idioma del texto de la transcripción.

task (`str`, *opcional*, valor predeterminado `None`) : Identificador de tarea que se añade al inicio de la secuencia (si lo hay).

predict_timestamps (`bool`, *opcional*, valor predeterminado `None`) : Si se debe omitir el token `<|notimestamps|>` al inicio de la secuencia.

Sobrescribe los tokens de prefijo que se agregan al inicio de la secuencia de etiquetas. Este método se puede usar de forma independiente para

actualice los tokens de prefijo según sea necesario durante el ajuste fino. Ejemplo:

```python
>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")
```

#### get_special_tokens_mask[[transformers.WhisperTokenizer.get_special_tokens_mask]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L669)

**Parámetros:**

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

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

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

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

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

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

#### save_vocabulary[[transformers.WhisperTokenizer.save_vocabulary]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L555)

#### batch_decode[[transformers.WhisperTokenizer.batch_decode]]

```python
batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

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

**Parámetros:**

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

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

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios de tokenización. Si es `None`, se usará por defecto `self.clean_up_tokenization_spaces`.

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

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

La lista de oraciones decodificadas.

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

Este método se proporciona por compatibilidad con versiones anteriores. El método `decode` ahora maneja la entrada por lotes de forma nativa, por lo que puede usar `decode` directamente en lugar de `batch_decode`.

#### decode[[transformers.WhisperTokenizer.decode]]

```python
decode(token_ids, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_offsets: bool = False, time_precision: float = 0.02, decode_with_timestamps: bool = False, normalize: bool = False, basic_normalize: bool = False, remove_diacritics: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L432)

**Parámetros:**

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

skip_special_tokens (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar los tokens especiales durante la decodificación. Si están presentes, se eliminarán los tokens anteriores (pre-prompt).

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar o no los espacios de tokenización. Si es `None`, se usará por defecto `self.clean_up_tokenization_spaces` (disponible en `tokenizer_config`).

output_offsets (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no mostrar los desplazamientos de los tokens. Esto solo debe configurarse si el modelo predijo marcas de tiempo. Si hay tokens previos (antes del prompt) para decodificar, solo aparecerán en el texto decodificado si contienen tokens de marca de tiempo.

time_precision (`float`, *opcional*, valor predeterminado 0.02) : La proporción de tiempo para convertir de token a tiempo.

decode_with_timestamps (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe decodificar con marcas de tiempo incluidas en el texto sin procesar.

normalize (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar el normalizador de texto en inglés al texto decodificado. Solo es aplicable cuando el texto de destino está en inglés. En caso contrario, se debe aplicar el normalizador de texto básico.

basic_normalize (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar el normalizador de texto básico al texto decodificado. Aplicable al texto de destino multilingüe.

remove_diacritics (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar las diacríticas al aplicar el normalizador de texto básico. La eliminación de diacríticas puede destruir información en el texto decodificado, por lo que debe usarse con precaución.

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

**Devuelve:** `str`

La frase decodificada.

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

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

#### basic_normalize[[transformers.WhisperTokenizer.basic_normalize]]

```python
basic_normalize(text, remove_diacritics = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/tokenization_whisper.py#L546)

Normaliza una cadena de texto dada mediante la clase `BasicTextNormalizer`, que realiza transformaciones comunes en texto multilingüe.

#### normalize[[transformers.WhisperTokenizer.normalize]]

```python
normalize(text)
```

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

Normaliza una cadena de texto dada mediante la clase `EnglishTextNormalizer`, que realiza transformaciones comunes en texto en inglés.

## WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]]

#### transformers.WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]]

```python
transformers.WhisperFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = False, **kwargs)
```

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

**Parámetros:**

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

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

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

chunk_length (`int`, *opcional*, valor predeterminado 30) : El número máximo de fragmentos de `sampling_rate` muestras utilizados para recortar y rellenar secuencias de audio más largas o más cortas.

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

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

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

Construye un extractor de características de Whisper.

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

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

#### __llamada__[[transformers.WhisperFeatureExtractor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/feature_extraction_whisper.py#L193)

**Parámetros:**

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

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

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

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

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

padding (`str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `'max_length'`) : Activa y controla el relleno. Acepta los siguientes valores:  - `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'` (predeterminado): Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `'do_not_pad'`: Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

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

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

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

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

- ****kwargs** : No es compatible con WhisperFeatureExtractor.__call__() y se ignora.

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

## WhisperProcessor[[transformers.WhisperProcessor]]

#### transformers.WhisperProcessor[[transformers.WhisperProcessor]]

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

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

**Parámetros:**

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

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

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

[WhisperProcessor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperProcessor) ofrece todas las funcionalidades de [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor) y [WhisperTokenizer](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperTokenizer). Consulte [~WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor) y [~WhisperTokenizer](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperTokenizer) para obtener más información.

#### __llamada__[[transformers.WhisperProcessor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/processing_whisper.py#L30)

**Parámetros:**

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

#### from_pretrained[[transformers.WhisperProcessor.from_pretrained]]

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

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

**Parámetros:**

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

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

Instanciar un procesador asociado con un modelo preentrenado.

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

#### save_pretrained[[transformers.WhisperProcessor.save_pretrained]]

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

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

**Parámetros:**

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

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

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

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

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

#### batch_decode[[transformers.WhisperProcessor.batch_decode]]

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

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

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

#### decode[[transformers.WhisperProcessor.decode]]

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

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

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

## WhisperModel[[transformers.WhisperModel]]

#### transformers.WhisperModel[[transformers.WhisperModel]]

```python
transformers.WhisperModel(config: WhisperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L826)

**Parámetros:**

config ([WhisperConfig](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperConfig)) : 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 Whisper básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

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

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

#### forward[[transformers.WhisperModel.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L891)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor). Consulte [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para obtener más detalles ([WhisperProcessor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperProcessor) utiliza [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor) para procesar audios).

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

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

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

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

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

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

decoder_position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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

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

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

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

- **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 decodificador del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

  Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

  Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:
```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperModel
>>> from datasets import load_dataset

>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]
```

#### _mask_input_features[[transformers.WhisperModel._mask_input_features]]

```python
_mask_input_features(input_features: Tensor, attention_mask: typing.Optional[torch.LongTensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L848)

Las máscaras extraen características a lo largo del eje temporal y/o del eje de características según [SpecAugment](https://huggingface.co/papers/1904.08779).

## WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]]

#### transformers.WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]]

```python
transformers.WhisperForConditionalGeneration(config: WhisperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L990)

**Parámetros:**

config ([WhisperConfig](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperConfig)) : 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 Whisper con una cabeza de modelado de lenguaje. Puede usarse para el reconocimiento automático de voz.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1034)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor). Consulte [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para obtener más detalles ([WhisperProcessor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperProcessor) utiliza [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor) para procesar audios).

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

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

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

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

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

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

decoder_position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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

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

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

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

El método forward de [WhisperForConditionalGeneration](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperForConditionalGeneration) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

  Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

  Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

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

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

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

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

#### generate[[transformers.WhisperForConditionalGeneration.generate]]

```python
generate(input_features: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool = False, return_timestamps: bool | None = None, task: str | None = None, language: str | list[str] | None = None, is_multilingual: bool | None = None, prompt_ids: typing.Optional[torch.Tensor] = None, prompt_condition_type: str | None = None, condition_on_prev_tokens: bool | None = None, temperature: float | tuple[float, ...] | None = None, compression_ratio_threshold: float | None = None, logprob_threshold: float | None = None, no_speech_threshold: float | None = None, num_segment_frames: int | None = None, attention_mask: typing.Optional[torch.Tensor] = None, time_precision: float = 0.02, time_precision_features: float = 0.01, return_token_timestamps: bool | None = None, return_segments: bool = False, return_dict_in_generate: bool | None = None, force_unique_generate_call: bool | None = None, monitor_progress: collections.abc.Callable[[torch.Tensor], None] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/generation_whisper.py#L383)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, feature_size, sequence_length)`, *opcional*) : Valores flotantes de características log-mel extraídas de la forma de onda de voz cruda. La forma de onda de voz cruda se puede 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_features`, se debe utilizar [AutoFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoFeatureExtractor) para extraer las características mel, aplicar relleno y convertirlo en un tensor de tipo `torch.Tensor`. Consulte [__call__()](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para más detalles.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los `**kwargs` pasados a generate que coincidan con los atributos de `generation_config` los sobrescribirán. Si no se proporciona `generation_config`, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo `generation_config.json`, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de [GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

logits_processor (`LogitsProcessorList`, *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Criterios de parada personalizados que complementan los criterios de parada predeterminados creados a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lote `batch_id` y `input_ids`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada al ID del lote `batch_id` y a los tokens generados previamente `inputs_ids`. Este argumento es útil para la generación restringida condicionada al prefijo, tal como se describe en [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe continuar ejecutando el bucle while hasta max_length (necesario para evitar bloqueos con `FullyShardedDataParallel` y DeepSpeed ZeRO Stage 3).

return_timestamps (`bool`, *opcional*) : Indica si se deben devolver las marcas de tiempo junto con el texto. Esto habilita `WhisperTimestampsLogitsProcessor`. Para audios de más de 30 segundos, es necesario establecer `return_timestamps=True`.

task (`str`, *opcional*) : Tarea a usar para la generación, ya sea "translate" o "transcribe".

language (`str` o lista de `str`, *opcional*) : Token de idioma a utilizar para la generación, puede estar en la forma de `<|en|>`, `en` o `english`. Para la generación por lotes, se puede pasar una lista de tokens de idioma. Puede encontrar todos los tokens de idioma posibles en el diccionario `model.generation_config.lang_to_id`.

is_multilingual (`bool`, *opcional*) : Indica si el modelo es multilingüe o no.

prompt_ids (`torch.Tensor`, *opcional*) : Tensor de rango 1 con IDs de tokens creado al pasar texto a `get_prompt_ids()` y proporcionado como prompt a cada chunk. Esto se puede usar para proporcionar o "prompt-engineer" un contexto para la transcripción, por ejemplo, vocabularios personalizados o nombres propios para aumentar la probabilidad de predecir esas palabras correctamente. No se puede usar en conjunto con `decoder_start_token_id` ya que sobrescribe este valor.

prompt_condition_type (`str`, *opcional*) : Solo es relevante para la transcripción de formato largo. Tipo de condición de `prompt_ids`. 'first-segment' significa que solo el primer segmento se condiciona en `prompt_ids`. 'all-segments' significa que cada segmento se condiciona en `prompt_ids`. Asegúrate de habilitar `condition_on_prev_tokens` para 'all-segments'. El valor predeterminado es 'first-segment'. Para la transcripción de corto plazo, solo es posible 'first-segment'.

condition_on_prev_tokens (`bool`, *opcional*) : Solo es relevante para la transcripción de formato largo. Indica si cada segmento debe condicionar en el segmento anterior. Como se muestra en [el paper de Whisper](https://cdn.openai.com/papers/whisper.pdf), esto puede ayudar a mejorar el rendimiento.

temperature (`float` o lista de `float`, *opcional*) : La temperatura que se utilizará para la generación. Si se pasa un único valor `float` y `do_sample=True`, se activa la generación mediante muestreo. Para transcripciones de formato largo, se puede activar el uso de temperaturas alternativas pasando una lista de valores float, como (0.0, 0.2, 0.4, 0.6, 0.8, 1.0). Como se muestra en [el paper de Whisper](https://cdn.openai.com/papers/whisper.pdf), esto puede ayudar a mejorar el rendimiento.

compression_ratio_threshold (`float`, *opcional*) : Solo es relevante para la transcripción de formato largo. Si se define, se calculará la tasa de compresión zlib de cada segmento. Si la tasa de compresión de un segmento es mayor que `compression_ratio_threshold`, se activa el fallback de temperatura: el segmento generado se descarta y la generación se repite utilizando una temperatura más alta. La intuición detrás de esta función es que los segmentos con tasas de compresión muy altas sufren de mucha repetición. La repetición no deseada se puede reducir inyectando más aleatoriedad aumentando la temperatura. Si `compression_ratio_threshold` está definido, asegúrese de que `temperature` sea una lista de valores. Un valor común para `compression_ratio_threshold` es 1.35. Como se muestra en [el paper de Whisper](https://cdn.openai.com/papers/whisper.pdf), esto puede ayudar a mejorar el rendimiento.

logprob_threshold (`float`, *opcional*) : Solo es relevante para la transcripción de formato largo. Si se define, se calculará la probabilidad logarítmica media de cada segmento. Si la probabilidad logarítmica de un segmento dado es menor que `logprob_threshold`, se activa el mecanismo de retroceso de temperatura: el segmento generado se descarta y la generación se repite utilizando una temperatura más alta. La intuición detrás de esta función es que los segmentos con baja probabilidad logarítmica pueden mejorarse inyectando más aleatoriedad mediante el aumento de la temperatura. Si `logprob_threshold` está definido, asegúrese de que `temperature` sea una lista de valores. Un valor común para `logprob_threshold` es -1.0. Como se muestra en [el paper de Whisper](https://cdn.openai.com/papers/whisper.pdf), esto puede ayudar a mejorar el rendimiento.

no_speech_threshold (`float`, *opcional*) : Solo es relevante para la transcripción de formato largo. Si se define, el token "no-speech" combinado con `logprob_threshold` se utiliza para determinar si un segmento contiene solo silencio. En este caso, se omite la transcripción de ese segmento. Como se muestra en [el paper de Whisper](https://cdn.openai.com/papers/whisper.pdf), esto puede ayudar a mejorar el rendimiento.

num_segment_frames (`int`, *opcional*) : El número de fotogramas de los que consta un segmento individual. Si no se define, `num_segment_frames` toma por defecto el stride del modelo multiplicado por la longitud máxima de entrada.

attention_mask (`torch.Tensor`, *opcional*) : `attention_mask` debe pasarse al realizar transcripciones de formato largo con un tamaño de lote > 1.

time_precision (`int`, *opcional*, valor predeterminado 0.02) : La duración del token de salida en segundos. *Por ejemplo*, 0.02 significa que un token generado representa en promedio 20 ms.

time_precision_features (`int`, *opcional*, valor predeterminado 0.01) : La duración representada por un fotograma de características en segundos.

return_token_timestamps (`bool`, *opcional*) : Indica si se deben devolver marcas de tiempo a nivel de token junto con el texto. Esto se puede usar con o sin la opción `return_timestamps`. Para obtener marcas de tiempo a nivel de palabra, use el tokenizador para agrupar los tokens en palabras.

return_segments (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver adicionalmente una lista de todos los segmentos. Tenga en cuenta que esta opción solo se puede habilitar al realizar transcripciones de formato largo.

return_dict_in_generate (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de solo los tokens generados. Tenga en cuenta que, al realizar transcripciones de formato largo, `return_dict_in_generate` solo se puede habilitar cuando `return_segments` está establecido en True. En este caso, las salidas de generación de cada segmento se añaden a cada segmento.

force_unique_generate_call (`bool`, *opcional*) : Si se debe forzar una llamada única al método [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) subyacente de GenerationMixin. Esto es útil para el decodificado asistido y con fines de prueba, para garantizar que solo se realice una llamada a [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) y, por lo tanto, se devuelvan los ids de tokens de entrada del decodificador y los ids de tokens eos.

monitor_progress (`Callable[[torch.Tensor], None]`, *opcional*) : Si se proporciona, esta función se puede llamar para informar sobre el progreso de la transcripción de audio. La función toma un argumento tensor `p` de forma `(n, 2)`, donde `n` es el tamaño del lote. `p[i, 0]` contiene el índice del fotograma de audio que se está transcribiendo actualmente para el elemento del lote `i`. `p[i, 1]` contiene el número total de fotogramas para el elemento del lote `i`. No se espera ningún valor de retorno.

kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de `generate_config` y/o kwargs específicos del modelo adicionales que se reenviarán a la función `forward` del modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo *decoder_*.

**Devuelve:** [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) o `dict[str, Any]` o `torch.LongTensor`

Una de las siguientes:
- [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) cuando `return_dict_in_generate=True` y (`return_timestamps=False` o `force_unique_generate_call=True`), que incluye los ids de entrada del decodificador y el id de fin de secuencia.
- `dict[str, Any]` cuando (`return_dict_in_generate=True` y `return_timestamps=True`) o `return_segments=True` o `return_token_timestamps=True`.
- `torch.LongTensor` en todos los demás casos, excluyendo los ids de entrada del decodificador y el id de fin de secuencia.

Los tipos posibles de [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) son:
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput)
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

`segments` es una lista de listas (una lista por elemento del lote) de `segment`. Un `segment` es un diccionario con las claves `start`, `end`, `tokens`, `idxs` y `result`.
- `start`: marca de tiempo de inicio del segmento.
- `end`: marca de tiempo final del segmento.
- `tokens`: los tokens del segmento, excluyendo los ids de entrada del decodificador y el id de fin de secuencia.
- `idxs`: los índices de inicio (incluido) y fin (excluido) de los `tokens` del segmento en la llamada subyacente a [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) de GenerationMixin (presente en `result`).
- `result`: el resultado de la llamada subyacente a [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) de GenerationMixin.

Cuando `return_timestamps=True`, `return_dict_in_generate=True` se aplica a cada llamada de [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) de la GenerationMixin subyacente, con las salidas almacenadas en `result` de cada `segment`.

Transcribe o traduce las características de entrada log-mel a una secuencia de ids de tokens generados de forma auto-regresiva.

La mayoría de los parámetros de control de generación se configuran en `generation_config`, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquier `generation_config` pasando los parámetros correspondientes a generate(), por ejemplo, `.generate(inputs, num_beams=4, do_sample=True)`.

Para obtener una visión general de las estrategias de generación y ejemplos de código, consulta la [siguiente guía](../generation_strategies).

Ejemplo:

- *Transcripción de formato largo*: Para transcribir o traducir audios de más de 30 segundos, procesa los archivos de audio sin truncarlos y pasa todas las características mel a generate de una sola vez. Es necesario establecer `return_timestamps=True`.
De hecho, la transcripción de audio largo utiliza un algoritmo secuencial basado en predicciones de marcas de tiempo, con heurísticas como el umbral de ratio de compresión, el umbral de probabilidad logarítmica y el fallback de temperatura. Este algoritmo se describe en [el artículo original de Whisper](https://cdn.openai.com/papers/whisper.pdf), sección *3.8. Long-form Transcription*.

```python
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()
>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]

>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)

>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs, return_timestamps=True)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."
```

El callback `monitor_progress` se puede utilizar para supervisar el progreso de la transcripción:
```python
>>> from tqdm import tqdm

>>> # prepare inputs like above

>>> # define a callback to monitor the progress of the transcription.
>>> with tqdm(desc="Progress") as pbar:
>>>     def monitor_progress(p_batch):
>>>         i = torch.argmax(p_batch[:, 1])
>>>         p = p_batch[i].detach().cpu()
>>>         pbar.total = int(p[1])
>>>         pbar.n = int(p[0])
>>>         pbar.update()

>>>     # transcribe audio to ids
>>>     generated_ids = model.generate(**inputs, return_timestamps=True, monitor_progress=monitor_progress)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
Progress:  95%|█████████████████████████████████████████████████████████████████████████████████████████████████▎    | 8497/8901 [00:04<00:00, 2052.79it/s]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."
```

- *Transcripción en formato corto*: Si las características de entrada mel pasadas son <= 30 segundos, hay dos posibilidades:
  - `return_timestamps=False`: se transcribirá todo el audio con una única llamada a [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) de GenerationMixin.
  - `return_timestamps=True`: el audio se transcribirá usando la misma lógica que la transcripción de formato largo.

```python
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

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

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

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

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

## WhisperForCausalLM[[transformers.WhisperForCausalLM]]

#### transformers.WhisperForCausalLM[[transformers.WhisperForCausalLM]]

```python
transformers.WhisperForCausalLM(config: WhisperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1171)

**Parámetros:**

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

Decodificador de Whisper con una cabeza de modelado de lenguaje en la parte superior (capa lineal con pesos vinculados a las incrustaciones de entrada).

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs)
```

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

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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)

encoder_outputs (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador.

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

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. Las etiquetas **no se desplazan** dentro del modelo. `labels[..., i]` es el objetivo para `logits[..., i, :]`, por lo que, para la predicción del siguiente token, las etiquetas ya deben estar desplazadas una posición hacia la izquierda en relación con `input_ids`.

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

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

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

El método forward de [WhisperForCausalLM](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperForCausalLM) 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.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de las atenciones cruzadas después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de atención) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.

Ejemplo:

```python
>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")

>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
...     sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features

>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)

>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'
```

## WhisperForAudioClassification[[transformers.WhisperForAudioClassification]]

#### transformers.WhisperForAudioClassification[[transformers.WhisperForAudioClassification]]

```python
transformers.WhisperForAudioClassification(config: WhisperConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1288)

**Parámetros:**

config ([WhisperConfig](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperConfig)) : 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 de codificador Whisper 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/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.WhisperForAudioClassification.forward]]

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/whisper/modeling_whisper.py#L1315)

**Parámetros:**

input_features (`torch.LongTensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor). Consulte [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para obtener más detalles ([WhisperProcessor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperProcessor) utiliza [WhisperFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/whisper#transformers.WhisperFeatureExtractor) para procesar audios).

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

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

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

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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")

>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> with torch.no_grad():
...     logits = model(input_features).logits

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'
```

