# SpeechT5

## Resumen

El modelo SpeechT5 fue propuesto en [SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing](https://huggingface.co/papers/2110.07205) por Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.

El resumen del artículo es el siguiente:

*Inspirados por el éxito de T5 (Text-To-Text Transfer Transformer) en modelos de procesamiento de lenguaje natural preentrenados, proponemos un marco unimodal SpeechT5 que explora el preentrenamiento encoder-decoder para el aprendizaje de representaciones auto-supervisadas de voz/texto. El marco SpeechT5 consiste en una red encoder-decoder compartida y seis redes pre/post específicas de cada modalidad (voz/texto). Después de preprocesar la entrada de voz/texto a través de las redes pre, la red encoder-decoder compartida modela la transformación de secuencia a secuencia, y luego las redes post generan la salida en la modalidad de voz/texto basándose en la salida del decodificador. Aprovechando grandes cantidades de datos de voz y texto sin etiquetar, preentrenamos SpeechT5 para aprender una representación unimodal, con la esperanza de mejorar la capacidad de modelado tanto para la voz como para el texto. Para alinear la información textual y de voz en este espacio semántico unificado, proponemos un enfoque de cuantización vectorial entre modalidades que mezcla aleatoriamente estados de voz/texto con unidades latentes como interfaz entre el codificador y el decodificador. Evaluaciones extensas muestran la superioridad del marco SpeechT5 propuesto en una amplia variedad de tareas de procesamiento de lenguaje hablado, incluyendo reconocimiento automático de voz, síntesis de voz, traducción de voz, conversión de voz, mejora de voz e identificación de hablantes.*

Este modelo fue aportado por [Matthijs](https://huggingface.co/Matthijs). El código original se puede encontrar [aquí](https://github.com/microsoft/SpeechT5).

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

## SpeechT5Config[[transformers.SpeechT5Config]]

#### transformers.SpeechT5Config[[transformers.SpeechT5Config]]

```python
transformers.SpeechT5Config(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 = 81, hidden_size: int = 768, encoder_layers: int = 12, encoder_attention_heads: int = 12, encoder_ffn_dim: int = 3072, encoder_layerdrop: float | int = 0.1, decoder_layers: int = 6, decoder_ffn_dim: int = 3072, decoder_attention_heads: int = 12, decoder_layerdrop: float | int = 0.1, hidden_act: str = 'gelu', positional_dropout: float | int = 0.1, hidden_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, scale_embedding: bool = False, feat_extract_norm: str = 'group', feat_proj_dropout: float | int = 0.0, feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, decoder_start_token_id: int | None = 2, num_mel_bins: int = 80, speech_decoder_prenet_layers: int = 2, speech_decoder_prenet_units: int = 256, speech_decoder_prenet_dropout: float | int = 0.5, speaker_embedding_dim: int = 512, speech_decoder_postnet_layers: int = 5, speech_decoder_postnet_units: int = 256, speech_decoder_postnet_kernel: int = 5, speech_decoder_postnet_dropout: float | int = 0.5, reduction_factor: int = 2, max_speech_positions: int = 4000, max_text_positions: int = 450, encoder_max_relative_position: int = 160, use_guided_attention_loss: bool = True, guided_attention_loss_num_heads: int = 2, guided_attention_loss_sigma: float = 0.4, guided_attention_loss_scale: float = 10.0, use_cache: bool = True, tie_word_embeddings: bool = True)
```

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

**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 `81`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

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

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

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

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

encoder_layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : 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_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador Transformer. Usará el mismo valor que `num_layers` si no se establece.

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

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

decoder_layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : 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.

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

positional_dropout (`float`, *opcional*, valor predeterminado 0.1) : La probabilidad de dropout para las capas de codificación de posición del texto.

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

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

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

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

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas.

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

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

feat_proj_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para la salida de la pre-red del codificador de voz.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

num_mel_bins (`int`, *opcional*, valor predeterminado 80) : Número de características mel utilizadas por cada entrada de características. Se usa en la pre-red del decodificador de voz. Debe corresponder al valor utilizado en la clase [SpeechT5Processor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor).

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

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

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

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

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

speech_decoder_prenet_layers (`int`, *opcional*, valor predeterminado 2) : Número de capas en la pre-red del decodificador de voz.

speech_decoder_prenet_units (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de las capas en la pre-red del decodificador de voz.

speech_decoder_prenet_dropout (`float`, *opcional*, valor predeterminado 0.5) : La probabilidad de dropout para las capas pre-net del decodificador de voz.

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

speech_decoder_postnet_layers (`int`, *opcional*, valor predeterminado 5) : Número de capas en la red posterior del decodificador de voz.

speech_decoder_postnet_units (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de las capas en la red posterior del decodificador de voz.

speech_decoder_postnet_kernel (`int`, *opcional*, valor predeterminado 5) : Número de canales de filtros convolucionales en la red posterior del decodificador de voz.

speech_decoder_postnet_dropout (`float`, *opcional*, valor predeterminado 0.5) : La probabilidad de dropout para las capas de la red posterior del decodificador de voz.

reduction_factor (`int`, *opcional*, valor predeterminado 2) : Factor de reducción de longitud del espectrograma para las entradas del decodificador de voz.

max_speech_positions (`int`, *opcional*, valor predeterminado 4000) : La longitud máxima de secuencia de características de voz con la que se podría utilizar este modelo.

max_text_positions (`int`, *opcional*, valor predeterminado 450) : La longitud máxima de secuencia de las características de texto con las que este modelo podría llegar a usarse.

encoder_max_relative_position (`int`, *opcional*, valor predeterminado 160) : Distancia máxima para la incrustación de posición relativa en el codificador.

use_guided_attention_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar la pérdida de atención guiada durante el entrenamiento del modelo TTS.

guided_attention_loss_num_heads (`int`, *opcional*, valor predeterminado: 2) : Número de cabezas de atención a las que se aplicará la pérdida de atención guiada. Use -1 para aplicar esta pérdida a todas las cabezas de atención.

guided_attention_loss_sigma (`float`, *opcional*, valor predeterminado 0.4) : Desviación estándar para la pérdida de atención guiada.

guided_attention_loss_scale (`float`, *opcional*, valor predeterminado 10.0) : Coeficiente de escalado para la pérdida de atención guiada (también conocido como lambda).

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.

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 SpeechT5Model. Se utiliza para instanciar un modelo Speecht5 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/speecht5_asr](https://huggingface.co/microsoft/speecht5_asr)

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

Ejemplo:

```python
>>> from transformers import SpeechT5Model, SpeechT5Config

>>> # Initializing a "microsoft/speecht5_asr" style configuration
>>> configuration = SpeechT5Config()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_asr" style configuration
>>> model = SpeechT5Model(configuration)

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

## SpeechT5HifiGanConfig[[transformers.SpeechT5HifiGanConfig]]

#### transformers.SpeechT5HifiGanConfig[[transformers.SpeechT5HifiGanConfig]]

```python
transformers.SpeechT5HifiGanConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, model_in_dim: int = 80, sampling_rate: int = 16000, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (4, 4, 4, 4), upsample_kernel_sizes: list[int] | tuple[int, ...] = (8, 8, 8, 8), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), initializer_range: float = 0.01, leaky_relu_slope: float = 0.1, normalize_before: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/configuration_speecht5.py#L225)

**Parámetros:**

model_in_dim (`int`, *opcional*, valor predeterminado: 80) : El número de bandas de frecuencia en el espectrograma log-mel de entrada.

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

upsample_initial_channel (`int`, *opcional*, valor predeterminado 512) : El número de canales de entrada de la red de remuestreo ascendente.

upsample_rates (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[4, 4, 4, 4]`) : Una tupla de enteros que define el paso de cada capa convolucional 1D en la red de remuestreo ascendente. La longitud de *upsample_rates* define el número de capas convolucionales y debe coincidir con la longitud de *upsample_kernel_sizes*.

upsample_kernel_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[8, 8, 8, 8]`) : Una tupla de enteros que define el tamaño del kernel de cada capa convolucional 1D en la red de remuestreo ascendente. La longitud de *upsample_kernel_sizes* define el número de capas convolucionales y debe coincidir con la longitud de *upsample_rates*.

resblock_kernel_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[3, 7, 11]`) : Una tupla de enteros que define los tamaños de los núcleos de las capas convolucionales 1D en el módulo de fusión de campos receptivos múltiples (MRF).

resblock_dilation_sizes (`tuple[tuple[int]]` o `list[list[int]]`, *opcional*, valor predeterminado `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Una tupla anidada de enteros que define las tasas de dilatación de las capas de convolución 1D dilatada en el módulo de fusión de campos receptivos múltiples (MRF).

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

leaky_relu_slope (`float`, *opcional*, valor predeterminado 0.1) : El ángulo de la pendiente negativa utilizado por la activación leaky ReLU.

normalize_before (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe normalizar el espectrograma antes de la vocodificación, utilizando la media y la varianza aprendidas por el vocoder.

Esta es la clase de configuración para almacenar la configuración de un SpeechT5Model. Se utiliza para instanciar un modelo Speecht5 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/speecht5_asr](https://huggingface.co/microsoft/speecht5_asr)

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

Ejemplo:

```python
>>> from transformers import SpeechT5HifiGan, SpeechT5HifiGanConfig

>>> # Initializing a "microsoft/speecht5_hifigan" style configuration
>>> configuration = SpeechT5HifiGanConfig()

>>> # Initializing a model (with random weights) from the "microsoft/speecht5_hifigan" style configuration
>>> model = SpeechT5HifiGan(configuration)

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

## SpeechT5Tokenizer[[transformers.SpeechT5Tokenizer]]

#### transformers.SpeechT5Tokenizer[[transformers.SpeechT5Tokenizer]]

```python
transformers.SpeechT5Tokenizer(vocab_file, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', normalize = False, sp_model_kwargs: dict[str, typing.Any] | None = None, **kwargs)
```

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

**Parámetros:**

vocab_file (`str`) : archivo [SentencePiece](https://github.com/google/sentencepiece) (generalmente con extensión *.spm*) que contiene el vocabulario necesario para instanciar un tokenizador.

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

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

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

pad_token (`str`, *opcional*, valor predeterminado `"<pad>"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.

normalize (`bool`, *opcional*, valor predeterminado `False`) : Si se deben convertir las cantidades numéricas del texto a su equivalente escrito en inglés.

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

sp_model (`SentencePieceProcessor`) : el procesador *SentencePiece* que se utiliza para cada conversión (cadenas, tokens e IDs).

Construye un tokenizador de SpeechT5. Basado en [SentencePiece](https://github.com/google/sentencepiece).

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

#### __llamada__[[transformers.SpeechT5Tokenizer.__call__]]

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

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

**Parámetros:**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#### save_vocabulary[[transformers.SpeechT5Tokenizer.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/tokenization_utils_sentencepiece.py#L237)

**Parámetros:**

save_directory (`str`) : El directorio en el que se guardará el vocabulario.

filename_prefix (`str`, *opcional*) : Un prefijo opcional para añadir al nombre de los archivos guardados.

**Devuelve:** `tuple(str)`

Rutas a los archivos guardados.

Guarde el vocabulario de sentencepiece (copie el archivo original) en un directorio.

#### decode[[transformers.SpeechT5Tokenizer.decode]]

```python
decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs)
```

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

**Parámetros:**

token_ids (`Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Una secuencia única o un lote (lista de secuencias) 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.

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

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

La cadena decodificada para una secuencia individual, o una lista de cadenas decodificadas para un lote de secuencias.

Convierte una secuencia de ids en una cadena de texto, o una lista de secuencias en una lista de cadenas 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))`.

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

## SpeechT5FeatureExtractor[[transformers.SpeechT5FeatureExtractor]]

#### transformers.SpeechT5FeatureExtractor[[transformers.SpeechT5FeatureExtractor]]

```python
transformers.SpeechT5FeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, do_normalize: bool = False, num_mel_bins: int = 80, hop_length: int = 16, win_length: int = 64, win_function: str = 'hann_window', fmin: float = 80, fmax: float = 7600, mel_floor: float = 1e-10, return_attention_mask: bool = True, **kwargs)
```

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

**Parámetros:**

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

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

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

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

num_mel_bins (`int`, *opcional*, valor predeterminado: 80) : El número de bandas de frecuencia mel en las características del espectrograma extraído.

hop_length (`int`, *opcional*, valor predeterminado 16) : Número de ms entre ventanas. También se denomina "shift" en muchos artículos.

win_length (`int`, *opcional*, valor predeterminado 64) : Número de ms por ventana.

win_function (`str`, *opcional*, valor predeterminado `"hann_window"`) : Nombre de la función de ventana utilizada para la ventana, debe ser accesible mediante `torch.{win_function}`

fmin (`float`, *opcional*, valor predeterminado 80) : Frecuencia mel mínima en Hz.

fmax (`float`, *opcional*, valor predeterminado 7600) : Frecuencia mel máxima en Hz.

mel_floor (`float`, *opcional*, valor predeterminado 1e-10) : Valor mínimo de los bancos de frecuencias mel.

return_attention_mask (`bool`, *opcional*, valor predeterminado `True`) : Indica si [__call__()](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5FeatureExtractor.__call__) debe devolver `attention_mask`.

Construye un extractor de características de SpeechT5.

Esta clase puede preprocesar una señal de voz cruda, normalizándola (opcionalmente) a media cero y varianza unitaria, para su uso por la red prenet del codificador de voz de SpeechT5.

Esta clase también puede extraer características de banco de filtros log-mel a partir de audio bruto, para su uso por la prenet del decodificador de voz de SpeechT5.

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

#### __llamada__[[transformers.SpeechT5FeatureExtractor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/feature_extraction_speecht5.py#L159)

**Parámetros:**

audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *opcional*) : La secuencia o el lote de secuencias a procesar. 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. Esto genera características de forma de onda. Debe ser audio de canal mono, no estéreo, es decir, un solo valor flotante por paso de tiempo.

audio_target (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *opcional*) : La secuencia o el lote de secuencias que se procesarán como objetivos. 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. Esto genera características de espectrograma log-mel.

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

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

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

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

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del feature_extractor específico.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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

sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada `audio` o `audio_target`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos.

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

Pasa un valor para `audio` para extraer características de la forma de onda. Pasa un valor para `audio_target` para extraer características del espectrograma log-mel.

## SpeechT5Processor[[transformers.SpeechT5Processor]]

#### transformers.SpeechT5Processor[[transformers.SpeechT5Processor]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/processing_speecht5.py#L21)

**Parámetros:**

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

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

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

[SpeechT5Processor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor) ofrece todas las funcionalidades de [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) y [SpeechT5Tokenizer](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Tokenizer). Consulte [~SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) y [~SpeechT5Tokenizer](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Tokenizer) para obtener más información.

#### __llamada__[[transformers.SpeechT5Processor.__call__]]

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

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

**Parámetros:**

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

#### pad[[transformers.SpeechT5Processor.pad]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/processing_speecht5.py#L74)

Coloca las entradas de audio y texto, así como sus objetivos, en un lote relleno.

Las entradas de audio se rellenan mediante [pad()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) de SpeechT5FeatureExtractor. Las entradas de texto se rellenan mediante [pad()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) de SpeechT5Tokenizer.

Las combinaciones de entrada válidas son:

- solo `input_ids`
- solo `input_values`
- solo `labels`, ya sean espectrogramas log-mel o tokens de texto
- `input_ids` y el espectrograma log-mel `labels`
- `input_values` y las etiquetas de texto `labels`

Consulte la docstring de los dos métodos anteriores para obtener más información.

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

## SpeechT5Model[[transformers.SpeechT5Model]]

#### transformers.SpeechT5Model[[transformers.SpeechT5Model]]

```python
transformers.SpeechT5Model(config: SpeechT5Config, encoder: typing.Optional[torch.nn.Module] = None, decoder: typing.Optional[torch.nn.Module] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L1852)

**Parámetros:**

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

encoder (`PreTrainedModel`, *opcional*) : El modelo codificador a utilizar.

decoder (`PreTrainedModel`, *opcional*) : El modelo decodificador a utilizar.

El modelo Encoder-Decoder de SpeechT5 sin procesar, que genera estados ocultos crudos sin ninguna red pre- o post-procesamiento específica.

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

```python
forward(input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L1894)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Dependiendo del codificador que se esté utilizando, `input_values` son: valores flotantes de la forma de onda de voz cruda de entrada, o índices de tokens de la secuencia de entrada en el vocabulario, o estados ocultos.

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_values (`torch.Tensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Dependiendo del decodificador que se esté utilizando, los `decoder_input_values` son: valores flotantes de características de banco de filtros log-mel extraídas de la forma de onda de voz cruda, o índices de tokens de la secuencia de entrada del decodificador en el vocabulario, o estados ocultos.

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_values`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `SpeechT5Decoder._prepare_decoder_attention_mask` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) para obtener más información sobre la estrategia predeterminada.

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

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

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

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor que contiene las incrustaciones de hablante.

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

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

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

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

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

## SpeechT5ForSpeechToText[[transformers.SpeechT5ForSpeechToText]]

#### transformers.SpeechT5ForSpeechToText[[transformers.SpeechT5ForSpeechToText]]

```python
transformers.SpeechT5ForSpeechToText(config: SpeechT5Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L1998)

**Parámetros:**

config ([SpeechT5Config](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Config)) : 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 SpeechT5 con un codificador de voz y un decodificador de texto.

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

```python
forward(input_values: 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2034)

**Parámetros:**

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

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 [SpeechT5Tokenizer](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Tokenizer). 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) SpeechT5 utiliza `eos_token_id` como token inicial para la generación de `decoder_input_ids`. Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`).

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

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

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

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

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

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

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

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]`. Los índices de las etiquetas se pueden obtener usando [SpeechT5Tokenizer](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Tokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles.

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

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

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

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_asr")
>>> model = SpeechT5ForSpeechToText.from_pretrained("microsoft/speecht5_asr")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> predicted_ids = model.generate(**inputs, max_length=100)

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

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

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

## SpeechT5ForTextToSpeech[[transformers.SpeechT5ForTextToSpeech]]

#### transformers.SpeechT5ForTextToSpeech[[transformers.SpeechT5ForTextToSpeech]]

```python
transformers.SpeechT5ForTextToSpeech(config: SpeechT5Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2310)

**Parámetros:**

config ([SpeechT5Config](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Config)) : 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 SpeechT5 con un codificador de texto y un decodificador 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.SpeechT5ForTextToSpeech.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, stop_labels: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2341)

**Parámetros:**

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

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_values (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`) : Valores flotantes del espectrograma mel de entrada. SpeechT5 utiliza un espectro de todos ceros como token de inicio para la generación de `decoder_input_values`. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_values` (ver `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_values`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `SpeechT5Decoder._prepare_decoder_attention_mask` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) para obtener más información sobre la estrategia predeterminada.

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

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

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

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

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

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

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor que contiene las incrustaciones de hablante.

labels (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`, *opcional*) : Valores flotantes del espectrograma mel objetivo. Los pasos de tiempo fijados en `-100.0` se ignoran (se enmascaran) para el cálculo de la pérdida. Los espectrogramas se pueden obtener usando [SpeechT5Processor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor). Consulte [SpeechT5Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para más detalles.

stop_labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tensor binario que indica la posición del token de parada en la secuencia.

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

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

El método forward de [SpeechT5ForTextToSpeech](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5ForTextToSpeech) 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 generación de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) -- El espectrograma predicho.
- **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
>>> from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, set_seed
>>> import torch

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
>>> model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([15872])
```

#### generate[[transformers.SpeechT5ForTextToSpeech.generate]]

```python
generate(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, threshold: float = 0.5, minlenratio: float = 0.0, maxlenratio: float = 20.0, vocoder: typing.Optional[torch.nn.Module] = None, output_cross_attentions: bool = False, return_output_lengths: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2464)

**Parámetros:**

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

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Máscara de atención del tokenizador, necesaria para la inferencia por lotes para indicar al modelo dónde debe ignorar los tokens de relleno de input_ids.

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor que contiene las incrustaciones de hablante.

threshold (`float`, *opcional*, valor predeterminado 0.5) : La secuencia generada termina cuando la probabilidad del token de parada predicho supera este valor.

minlenratio (`float`, *opcional*, valor predeterminado 0.0) : Se utiliza para calcular la longitud mínima requerida para la secuencia de salida.

maxlenratio (`float`, *opcional*, valor predeterminado 20.0) : Se utiliza para calcular la longitud máxima permitida de la secuencia de salida.

vocoder (`nn.Module`, *opcional*) : El vocoder que convierte el espectrograma mel en una forma de onda de voz. Si es `None`, la salida es el espectrograma mel.

output_cross_attentions (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver los tensores de atención de las capas de atención cruzada del decodificador.

return_output_lengths (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las longitudes concretas del espectrograma/forma de onda.

**Devuelve:** `tuple(torch.Tensor)` que comprende varios elementos según las entradas

- cuando `return_output_lengths` es False
  - **espectrograma** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `torch.Tensor` de forma `(output_sequence_length, config.num_mel_bins)` -- El espectrograma log-mel predicho.
  - **waveform** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `torch.Tensor` de forma `(num_frames,)` -- La forma de onda de voz predicha.
  - **cross_attentions** (*opcional*, se devuelve cuando `output_cross_attentions` es `True`) `torch.Tensor` de forma `(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- Las salidas de las capas de atención cruzada del decodificador.
- cuando `return_output_lengths` es True
  - **espectrogramas** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `torch.Tensor` de forma `(batch_size, output_sequence_length, config.num_mel_bins)` -- Los espectrogramas log-mel predichos, rellenos hasta la longitud máxima.
  - **spectrogram_lengths** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `list[Int]` -- Una lista con las longitudes concretas de cada espectrograma.
  - **formas de onda** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `torch.Tensor` de forma `(batch_size, num_frames)` -- Las formas de onda de voz predichas, rellenas hasta la longitud máxima.
  - **waveform_lengths** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `list[Int]` -- Una lista con las longitudes concretas de cada forma de onda.
  - **cross_attentions** (*opcional*, se devuelve cuando `output_cross_attentions` es `True`) `torch.Tensor` de forma `(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- Las salidas de las capas de atención cruzada del decodificador.

Convierte una secuencia de tokens de entrada en una secuencia de espectrogramas mel, que luego se transforman en una forma de onda de voz mediante un vocoder.

## SpeechT5ForSpeechToSpeech[[transformers.SpeechT5ForSpeechToSpeech]]

#### transformers.SpeechT5ForSpeechToSpeech[[transformers.SpeechT5ForSpeechToSpeech]]

```python
transformers.SpeechT5ForSpeechToSpeech(config: SpeechT5Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2658)

**Parámetros:**

config ([SpeechT5Config](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Config)) : 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 SpeechT5 con un codificador de voz y un decodificador 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.SpeechT5ForSpeechToSpeech.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_values: typing.Optional[torch.Tensor] = 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, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, speaker_embeddings: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, stop_labels: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2678)

**Parámetros:**

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

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_values (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`) : Valores flotantes del espectrograma mel de entrada. SpeechT5 utiliza un espectro de todos ceros como token de inicio para la generación de `decoder_input_values`. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_values` (ver `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_values`. También se usará una máscara causal de forma predeterminada. Si desea cambiar el comportamiento de relleno, debe leer `SpeechT5Decoder._prepare_decoder_attention_mask` y modificarlo según sus necesidades. Consulte el diagrama 1 de [el artículo](https://huggingface.co/papers/1910.13461) para obtener más información sobre la estrategia predeterminada.

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

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

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

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

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

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

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor que contiene las incrustaciones de hablante.

labels (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_mel_bins)`, *opcional*) : Valores flotantes del espectrograma mel objetivo. Los espectrogramas se pueden obtener usando [SpeechT5Processor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor). Consulte [SpeechT5Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5Processor.__call__) para más detalles.

stop_labels (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Tensor binario que indica la posición del token de parada en la secuencia.

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

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

El método forward de [SpeechT5ForSpeechToSpeech](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5ForSpeechToSpeech) 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 generación de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) -- El espectrograma predicho.
- **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
>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToSpeech, SpeechT5HifiGan, set_seed
>>> from datasets import load_dataset
>>> import torch

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

>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_vc")
>>> model = SpeechT5ForSpeechToSpeech.from_pretrained("microsoft/speecht5_vc")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")

>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> speaker_embeddings = torch.zeros((1, 512))  # or load xvectors from a file

>>> set_seed(555)  # make deterministic

>>> # generate speech
>>> speech = model.generate_speech(inputs["input_values"], speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([77824])
```

#### generate_speech[[transformers.SpeechT5ForSpeechToSpeech.generate_speech]]

```python
generate_speech(input_values: Tensor, speaker_embeddings: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, threshold: float = 0.5, minlenratio: float = 0.0, maxlenratio: float = 20.0, vocoder: typing.Optional[torch.nn.Module] = None, output_cross_attentions: bool = False, return_output_lengths: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2796)

**Parámetros:**

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

speaker_embeddings (`torch.Tensor` de forma `(batch_size, config.speaker_embedding_dim)`, *opcional*) : Tensor que contiene las incrustaciones de hablante.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar convolución y 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)

threshold (`float`, *opcional*, valor predeterminado 0.5) : La secuencia generada termina cuando la probabilidad del token de parada predicho supera este valor.

minlenratio (`float`, *opcional*, valor predeterminado 0.0) : Se utiliza para calcular la longitud mínima requerida para la secuencia de salida.

maxlenratio (`float`, *opcional*, valor predeterminado 20.0) : Se utiliza para calcular la longitud máxima permitida de la secuencia de salida.

vocoder (`nn.Module`, *opcional*, valor predeterminado `None`) : El vocoder que convierte el espectrograma mel en una forma de onda de voz. Si es `None`, la salida es el espectrograma mel.

output_cross_attentions (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver los tensores de atención de las capas de atención cruzada del decodificador.

return_output_lengths (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver o no las longitudes concretas del espectrograma/forma de onda.

**Devuelve:** `tuple(torch.Tensor)` que comprende varios elementos según las entradas

- cuando `return_output_lengths` es False
  - **espectrograma** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `torch.Tensor` de forma `(output_sequence_length, config.num_mel_bins)` -- El espectrograma log-mel predicho.
  - **waveform** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `torch.Tensor` de forma `(num_frames,)` -- La forma de onda de voz predicha.
  - **cross_attentions** (*opcional*, se devuelve cuando `output_cross_attentions` es `True`) `torch.Tensor` de forma `(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- Las salidas de las capas de atención cruzada del decodificador.
- cuando `return_output_lengths` es True
  - **espectrogramas** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `torch.Tensor` de forma `(batch_size, output_sequence_length, config.num_mel_bins)` -- Los espectrogramas log-mel predichos, rellenos hasta la longitud máxima.
  - **spectrogram_lengths** (*opcional*, se devuelve cuando no se proporciona un `vocoder`) `list[Int]` -- Una lista con las longitudes concretas de cada espectrograma.
  - **formas de onda** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `torch.Tensor` de forma `(batch_size, num_frames)` -- Las formas de onda de voz predichas, rellenas hasta la longitud máxima.
  - **waveform_lengths** (*opcional*, se devuelve cuando se proporciona un `vocoder`) `list[Int]` -- Una lista con las longitudes concretas de cada forma de onda.
  - **cross_attentions** (*opcional*, se devuelve cuando `output_cross_attentions` es `True`) `torch.Tensor` de forma `(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)` -- Las salidas de las capas de atención cruzada del decodificador.

Convierte una forma de onda de voz cruda en una secuencia de espectrogramas mel, que luego se reconvierten en una forma de onda de voz mediante un vocoder.

## SpeechT5HifiGan[[transformers.SpeechT5HifiGan]]

#### transformers.SpeechT5HifiGan[[transformers.SpeechT5HifiGan]]

```python
transformers.SpeechT5HifiGan(config: SpeechT5HifiGanConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L2954)

**Parámetros:**

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

Vocoder HiFi-GAN.

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

```python
forward(spectrogram: Tensor, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/speecht5/modeling_speecht5.py#L3022)

**Parámetros:**

spectrogram (`torch.Tensor`) : Tensor que contiene los espectrogramas log-mel. Puede estar agrupado (batched) y tener forma `(batch_size, sequence_length, config.model_in_dim)`, o no estar agrupado y tener forma `(sequence_length, config.model_in_dim)`.

**Devuelve:** `torch.Tensor`

Tensor que contiene la forma de onda del habla. Si el espectrograma de entrada está agrupado, tendrá la forma `(batch_size, num_frames,)`. Si no está agrupado, tendrá la forma `(num_frames,)`.

Convierte un espectrograma log-mel en una forma de onda de voz. Al pasar un lote de espectrogramas log-mel, devuelve un lote de formas de onda de voz. Al pasar un espectrograma log-mel individual, sin lote, devuelve una forma de onda de voz individual, sin lote.

