# FastSpeech2Conformer

## Resumen

El modelo FastSpeech2Conformer fue propuesto en el artículo [Recent Developments On Espnet Toolkit Boosted By Conformer](https://huggingface.co/papers/2010.13956) de Pengcheng Guo, Florian Boyer, Xuankai Chang, Tomoki Hayashi, Yosuke Higuchi, Hirofumi Inaguma, Naoyuki Kamo, Chenda Li, Daniel Garcia-Romero, Jiatong Shi, Jing Shi, Shinji Watanabe, Kun Wei, Wangyou Zhang y Yuekai Zhang.

El resumen del artículo original de FastSpeech2 es el siguiente:

*Los modelos de texto a voz (TTS) no autorregresivos, como FastSpeech (Ren et al., 2019), pueden sintetizar voz de manera significativamente más rápida que los modelos autorregresivos anteriores, con una calidad comparable. El entrenamiento del modelo FastSpeech depende de un modelo maestro autorregresivo para la predicción de duración (para proporcionar más información como entrada) y de la destilación de conocimiento (para simplificar la distribución de datos en la salida), lo que puede aliviar el problema de mapeo uno a muchos (es decir, múltiples variaciones de voz corresponden al mismo texto) en TTS. Sin embargo, FastSpeech presenta varias desventajas: 1) el pipeline de destilación maestro-estudiante es complicado y consume mucho tiempo, 2) la duración extraída del modelo maestro no es lo suficientemente precisa, y los mel-espectrogramas objetivo destilados del modelo maestro sufren pérdida de información debido a la simplificación de los datos, lo cual limita la calidad de la voz. En este artículo, proponemos FastSpeech 2, que aborda los problemas de FastSpeech y resuelve mejor el problema de mapeo uno a muchos en TTS mediante 1) el entrenamiento directo del modelo con el objetivo real en lugar de la salida simplificada del maestro, y 2) la introducción de más información de variación de la voz (p. ej., tono, energía y duración más precisa) como entradas condicionales. Específicamente, extraemos la duración, el tono y la energía de la forma de onda de la voz y los tomamos directamente como entradas condicionales durante el entrenamiento, y usamos los valores predichos en la inferencia. Además, diseñamos FastSpeech 2s, que es el primer intento de generar directamente la forma de onda de la voz a partir del texto en paralelo, aprovechando el beneficio de una inferencia totalmente de extremo a extremo. Los resultados experimentales muestran que 1) FastSpeech 2 logra una aceleración de entrenamiento 3 veces mayor que FastSpeech, y FastSpeech 2s disfruta de una velocidad de inferencia aún más rápida; 2) FastSpeech 2 y 2s superan a FastSpeech en calidad de voz, y FastSpeech 2 incluso puede superar a los modelos autorregresivos. Las muestras de audio están disponibles en https://speechresearch.github.io/fastspeech2/.*

Este modelo fue aportado por [Connor Henderson](https://huggingface.co/connor-henderson). El código original se puede encontrar [aquí](https://github.com/espnet/espnet/blob/master/espnet2/tts/fastspeech2/fastspeech2.py).

## 🤗 Arquitectura del modelo

Se implementó la estructura general de FastSpeech2 con un decodificador de Mel-espectrograma, y los bloques de transformer tradicionales se reemplazaron con bloques conformer, tal como se hace en la biblioteca ESPnet.

### Arquitectura del modelo FastSpeech2

![FastSpeech2 Model Architecture](https://www.microsoft.com/en-us/research/uploads/prod/2021/04/fastspeech2-1.png)

#### Bloques Conformer

![Conformer Blocks](https://www.researchgate.net/profile/Hirofumi-Inaguma-2/publication/344911155/figure/fig2/AS:951455406108673@1603856054097/An-overview-of-Conformer-block.png)

#### Módulo de convolución

![Convolution Module](https://d3i71xaburhd42.cloudfront.net/8809d0732f6147d4ad9218c8f9b20227c837a746/2-Figure1-1.png)

## Uso de 🤗 Transformers

Puedes ejecutar FastSpeech2Conformer localmente con la biblioteca 🤗 Transformers.

1. Primero instala la biblioteca [Transformers](https://github.com/huggingface/transformers) de 🤗, g2p-en:

```bash
pip install --upgrade pip
pip install --upgrade transformers g2p-en
```

2. Ejecuta la inferencia mediante el código de modelado de Transformers con el modelo y hifigan por separado

```python
import soundfile as sf

from transformers import FastSpeech2ConformerHifiGan, FastSpeech2ConformerModel, FastSpeech2ConformerTokenizer

tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
inputs = tokenizer("Hello, my dog is cute.", return_tensors="pt").to(model.device)
input_ids = inputs["input_ids"]

model = FastSpeech2ConformerModel.from_pretrained("espnet/fastspeech2_conformer", device_map="auto")
output_dict = model(input_ids, return_dict=True)
spectrogram = output_dict["spectrogram"]

hifigan = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
waveform = hifigan(spectrogram)

sf.write("speech.wav", waveform.squeeze().detach().numpy(), samplerate=22050)
```

3. Ejecuta la inferencia mediante el código de modelado de Transformers con el modelo y hifigan combinados

```python
import soundfile as sf

from transformers import FastSpeech2ConformerTokenizer, FastSpeech2ConformerWithHifiGan

tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
inputs = tokenizer("Hello, my dog is cute.", return_tensors="pt").to(model.device)
input_ids = inputs["input_ids"]

model = FastSpeech2ConformerWithHifiGan.from_pretrained("espnet/fastspeech2_conformer_with_hifigan")
output_dict = model(input_ids, return_dict=True)
waveform = output_dict["waveform"]

sf.write("speech.wav", waveform.squeeze().detach().numpy(), samplerate=22050)
```

4. Ejecuta la inferencia con un pipeline y especifica qué vocoder usar

```python
import soundfile as sf

from transformers import FastSpeech2ConformerHifiGan, pipeline

vocoder = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
synthesiser = pipeline(model="espnet/fastspeech2_conformer", vocoder=vocoder)

speech = synthesiser("Hello, my dog is cooler than you!")

sf.write("speech.wav", speech["audio"].squeeze(), samplerate=speech["sampling_rate"])
```

## FastSpeech2ConformerConfig[[transformers.FastSpeech2ConformerConfig]]

#### transformers.FastSpeech2ConformerConfig[[transformers.FastSpeech2ConformerConfig]]

```python
transformers.FastSpeech2ConformerConfig(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, hidden_size: int = 384, vocab_size: int = 78, num_mel_bins: int = 80, encoder_num_attention_heads: int = 2, encoder_layers: int = 4, encoder_linear_units: int = 1536, decoder_layers: int = 4, decoder_num_attention_heads: int = 2, decoder_linear_units: int = 1536, speech_decoder_postnet_layers: int = 5, speech_decoder_postnet_units: int = 256, speech_decoder_postnet_kernel: int = 5, positionwise_conv_kernel_size: int = 3, encoder_normalize_before: bool = False, decoder_normalize_before: bool = False, encoder_concat_after: bool = False, decoder_concat_after: bool = False, reduction_factor: int = 1, speaking_speed: float = 1.0, use_macaron_style_in_conformer: bool = True, use_cnn_in_conformer: bool = True, encoder_kernel_size: int = 7, decoder_kernel_size: int = 31, duration_predictor_layers: int = 2, duration_predictor_channels: int = 256, duration_predictor_kernel_size: int = 3, energy_predictor_layers: int = 2, energy_predictor_channels: int = 256, energy_predictor_kernel_size: int = 3, energy_predictor_dropout: float | int = 0.5, energy_embed_kernel_size: int = 1, energy_embed_dropout: float | int = 0.0, stop_gradient_from_energy_predictor: bool = False, pitch_predictor_layers: int = 5, pitch_predictor_channels: int = 256, pitch_predictor_kernel_size: int = 5, pitch_predictor_dropout: float | int = 0.5, pitch_embed_kernel_size: int = 1, pitch_embed_dropout: float | int = 0.0, stop_gradient_from_pitch_predictor: bool = True, encoder_dropout_rate: float | int = 0.2, encoder_positional_dropout_rate: float | int = 0.2, encoder_attention_dropout_rate: float | int = 0.2, decoder_dropout_rate: float | int = 0.2, decoder_positional_dropout_rate: float | int = 0.2, decoder_attention_dropout_rate: float | int = 0.2, duration_predictor_dropout_rate: float | int = 0.2, speech_decoder_postnet_dropout: float | int = 0.5, max_source_positions: int = 5000, use_masking: bool = True, use_weighted_masking: bool = False, num_speakers: int | None = None, num_languages: int | None = None, speaker_embed_dim: int | None = None, convolution_bias: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L27)

**Parámetros:**

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

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

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

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

encoder_num_attention_heads (`int`, *opcional*, valor predeterminado 2) : El número de cabezas de atención en el codificador.

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

encoder_linear_units (`int`, *opcional*, valor predeterminado 1536) : El número de unidades en la capa lineal del codificador.

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

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

decoder_linear_units (`int`, *opcional*, valor predeterminado 1536) : El número de unidades en la capa lineal del decodificador.

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

speech_decoder_postnet_units (`int`, *opcional*, valor predeterminado 256) : El número de unidades en las capas post-net del decodificador de voz.

speech_decoder_postnet_kernel (`int`, *opcional*, valor predeterminado 5) : El tamaño del kernel en la red posterior del decodificador de voz.

positionwise_conv_kernel_size (`int`, *opcional*, valor predeterminado 3) : El tamaño del núcleo de convolución utilizado en la capa posicional.

encoder_normalize_before (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se debe normalizar antes de las capas del codificador.

decoder_normalize_before (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se debe normalizar antes de las capas del decodificador.

encoder_concat_after (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se debe concatenar después de las capas del codificador.

decoder_concat_after (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se debe concatenar después de las capas del decodificador.

reduction_factor (`int`, *opcional*, valor predeterminado: 1) : El factor por el cual se reduce la frecuencia de fotogramas del audio.

speaking_speed (`float`, *opcional*, valor predeterminado 1.0) : La velocidad del audio generado.

use_macaron_style_in_conformer (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar el estilo macaron en el conformer.

use_cnn_in_conformer (`bool`, *opcional*, valor predeterminado `True`) : Especifica si se deben usar redes neuronales convolucionales en el conformer.

encoder_kernel_size (`int`, *opcional*, valor predeterminado 7) : El tamaño del kernel utilizado en el codificador.

decoder_kernel_size (`int`, *opcional*, valor predeterminado 31) : El tamaño del kernel utilizado en el decodificador.

duration_predictor_layers (`int`, *opcional*, valor predeterminado 2) : El número de capas en el predictor de duración.

duration_predictor_channels (`int`, *opcional*, valor predeterminado 256) : El número de canales en el predictor de duración.

duration_predictor_kernel_size (`int`, *opcional*, valor predeterminado: 3) : El tamaño del kernel utilizado en el predictor de duración.

energy_predictor_layers (`int`, *opcional*, valor predeterminado 2) : El número de capas en el predictor de energía.

energy_predictor_channels (`int`, *opcional*, valor predeterminado 256) : El número de canales en el predictor de energía.

energy_predictor_kernel_size (`int`, *opcional*, valor predeterminado 3) : El tamaño del kernel utilizado en el predictor de energía.

energy_predictor_dropout (`float`, *opcional*, valor predeterminado 0.5) : La tasa de dropout en el predictor de energía.

energy_embed_kernel_size (`int`, *opcional*, valor predeterminado 1) : El tamaño del kernel utilizado en la capa de incrustación de energía.

energy_embed_dropout (`float`, *opcional*, valor predeterminado 0.0) : La tasa de dropout en la capa de incrustación de energía.

stop_gradient_from_energy_predictor (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se deben detener los gradientes del predictor de energía.

pitch_predictor_layers (`int`, *opcional*, valor predeterminado: 5) : El número de capas en el predictor de tono.

pitch_predictor_channels (`int`, *opcional*, valor predeterminado 256) : El número de canales en el predictor de tono.

pitch_predictor_kernel_size (`int`, *opcional*, valor predeterminado 5) : El tamaño del kernel utilizado en el predictor de tono.

pitch_predictor_dropout (`float`, *opcional*, valor predeterminado 0.5) : La tasa de dropout en el predictor de tono.

pitch_embed_kernel_size (`int`, *opcional*, valor predeterminado 1) : El tamaño del kernel utilizado en la capa de incrustación de tono.

pitch_embed_dropout (`float`, *opcional*, valor predeterminado 0.0) : La tasa de dropout en la capa de incrustación de tono.

stop_gradient_from_pitch_predictor (`bool`, *opcional*, valor predeterminado `True`) : Especifica si se deben detener los gradientes desde el predictor de tono.

encoder_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout en el codificador.

encoder_positional_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout posicional en el codificador.

encoder_attention_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout de la atención en el codificador.

decoder_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout en el decodificador.

decoder_positional_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout posicional en el decodificador.

decoder_attention_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout de atención en el decodificador.

duration_predictor_dropout_rate (`float`, *opcional*, valor predeterminado 0.2) : La tasa de dropout en el predictor de duración.

speech_decoder_postnet_dropout (`float`, *opcional*, valor predeterminado 0.5) : La tasa de dropout en la red posterior del decodificador de voz.

max_source_positions (`int`, *opcional*, valor predeterminado 5000) : si se usan embeddings de posición `"relative"`, define las posiciones de entrada de origen máximas.

use_masking (`bool`, *opcional*, valor predeterminado `True`) : Especifica si se debe usar enmascaramiento en el modelo.

use_weighted_masking (`bool`, *opcional*, valor predeterminado `False`) : Especifica si se debe usar enmascarado ponderado en el modelo.

num_speakers (`int`, *opcional*) : Número de hablantes. Si se establece en > 1, se asume que los ids de hablante se proporcionarán como entrada y se usará la capa de embedding de id de hablante.

num_languages (`int`, *opcional*) : Número de idiomas. Si se establece en > 1, se asume que los ids de idioma se proporcionarán como entrada y se usará la capa de incrustación de id de idioma.

speaker_embed_dim (`int`, *opcional*) : Dimensión del embedding del hablante. Si se establece en > 0, se asume que speaker_embedding se proporcionará como entrada.

convolution_bias (`bool`, *opcional*, valor predeterminado `True`) : Especifica si se debe usar sesgo en las convoluciones del módulo de convolución del conformer.

Esta es la clase de configuración para almacenar la configuración de un FastSpeech2ConformerModel. Se utiliza para instanciar un modelo Fastspeech2 Conformer 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 [espnet/fastspeech2_conformer](https://huggingface.co/espnet/fastspeech2_conformer)

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

Ejemplo:

```python
>>> from transformers import FastSpeech2ConformerModel, FastSpeech2ConformerConfig

>>> # Initializing a FastSpeech2Conformer style configuration
>>> configuration = FastSpeech2ConformerConfig()

>>> # Initializing a model from the FastSpeech2Conformer style configuration
>>> model = FastSpeech2ConformerModel(configuration)

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

## FastSpeech2ConformerHifiGanConfig[[transformers.FastSpeech2ConformerHifiGanConfig]]

#### transformers.FastSpeech2ConformerHifiGanConfig[[transformers.FastSpeech2ConformerHifiGanConfig]]

```python
transformers.FastSpeech2ConformerHifiGanConfig(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, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (8, 8, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (16, 16, 4, 4), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple | None = None, initializer_range: float = 0.01, leaky_relu_slope: float = 0.1, normalize_before: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L267)

**Parámetros:**

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

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 `[8, 8, 2, 2]`) : 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 `[16, 16, 4, 4]`) : 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 FastSpeech2ConformerModel. Se utiliza para instanciar un modelo Fastspeech2 Conformer 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 [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

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

Ejemplo:

```python
>>> from transformers import FastSpeech2ConformerHifiGan, FastSpeech2ConformerHifiGanConfig

>>> # Initializing a FastSpeech2ConformerHifiGan configuration
>>> configuration = FastSpeech2ConformerHifiGanConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = FastSpeech2ConformerHifiGan(configuration)

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

## FastSpeech2ConformerWithHifiGanConfig[[transformers.FastSpeech2ConformerWithHifiGanConfig]]

#### transformers.FastSpeech2ConformerWithHifiGanConfig[[transformers.FastSpeech2ConformerWithHifiGanConfig]]

```python
transformers.FastSpeech2ConformerWithHifiGanConfig(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_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L328)

**Parámetros:**

model_config (`FastSpeech2ConformerConfig | dict`, *opcional*) : Configuración del modelo de texto a voz.

vocoder_config (`FastSpeech2ConformerHiFiGanConfig | dict`, *opcional*) : Configuración del modelo vocoder.

Esta es la clase de configuración para almacenar la configuración de un FastSpeech2ConformerModel. Se utiliza para instanciar un modelo Fastspeech2 Conformer 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 [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

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

Ejemplo:

```python
>>> from transformers import (
...     FastSpeech2ConformerConfig,
...     FastSpeech2ConformerHifiGanConfig,
...     FastSpeech2ConformerWithHifiGanConfig,
...     FastSpeech2ConformerWithHifiGan,
... )

>>> # Initializing FastSpeech2ConformerWithHifiGan sub-modules configurations.
>>> model_config = FastSpeech2ConformerConfig()
>>> vocoder_config = FastSpeech2ConformerHifiGanConfig()

>>> # Initializing a FastSpeech2ConformerWithHifiGan module style configuration
>>> configuration = FastSpeech2ConformerWithHifiGanConfig(model_config.to_dict(), vocoder_config.to_dict())

>>> # Initializing a model (with random weights)
>>> model = FastSpeech2ConformerWithHifiGan(configuration)

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

## FastSpeech2ConformerTokenizer[[transformers.FastSpeech2ConformerTokenizer]]

#### transformers.FastSpeech2ConformerTokenizer[[transformers.FastSpeech2ConformerTokenizer]]

```python
transformers.FastSpeech2ConformerTokenizer(vocab_file, bos_token = '<sos/eos>', eos_token = '<sos/eos>', pad_token = '<blank>', unk_token = '<unk>', should_strip_spaces = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L30)

**Parámetros:**

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

bos_token (`str`, *opcional*, valor predeterminado `"<sos/eos>"`) : El token de inicio de secuencia. Tenga en cuenta que, en el caso de FastSpeech2, es el mismo que `eos_token`.

eos_token (`str`, *opcional*, por defecto `"<sos/eos>"`) : El token de fin de secuencia. Tenga en cuenta que, en el caso de FastSpeech2, es el mismo que `bos_token`.

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

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.

should_strip_spaces (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben eliminar los espacios de la lista de tokens.

Construya un tokenizador FastSpeech2Conformer.

#### __llamada__[[transformers.FastSpeech2ConformerTokenizer.__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/main/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/main/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/main/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/main/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/main/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/main/es/main_classes/tokenizer#transformers.BatchEncoding)

Un [BatchEncoding](/docs/transformers/main/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.FastSpeech2ConformerTokenizer.save_vocabulary]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L145)

**Parámetros:**

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

**Devuelve:** `Tuple(str)`

Rutas a los archivos guardados.

Guarde el archivo de vocabulario y tokens especiales en un directorio.

#### decode[[transformers.FastSpeech2ConformerTokenizer.decode]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L132)

#### batch_decode[[transformers.FastSpeech2ConformerTokenizer.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/main/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`.

## FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

#### transformers.FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

```python
transformers.FastSpeech2ConformerModel(config: FastSpeech2ConformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1021)

**Parámetros:**

config ([FastSpeech2ConformerConfig](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo FastSpeech2Conformer.

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

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

#### forward[[transformers.FastSpeech2ConformerModel.forward]]

```python
forward(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, spectrogram_labels: typing.Optional[torch.Tensor] = None, duration_labels: typing.Optional[torch.LongTensor] = None, pitch_labels: typing.Optional[torch.Tensor] = None, energy_labels: typing.Optional[torch.Tensor] = None, speaker_ids: typing.Optional[torch.LongTensor] = None, lang_ids: typing.Optional[torch.LongTensor] = None, speaker_embedding: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1098)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Secuencia de entrada de vectores de texto.

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)

spectrogram_labels (`torch.Tensor` de forma `(batch_size, max_spectrogram_length, num_mel_bins)`, *opcional*, valor predeterminado `None`) : Lote de características objetivo rellenas.

duration_labels (`torch.LongTensor` de forma `(batch_size, sequence_length + 1)`, *opcional*, valor predeterminado `None`) : Lote de duraciones rellenas.

pitch_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, valor predeterminado `None`) : Lote de tono promedio por token con relleno.

energy_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, valor predeterminado `None`) : Lote de energía promedio por token con relleno.

speaker_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, valor predeterminado `None`) : Ids de hablante utilizados para condicionar las características de la salida de voz del modelo.

lang_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, valor predeterminado `None`) : Idiomas utilizados para condicionar las características de la salida de voz del modelo.

speaker_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`, *opcional*, valor predeterminado `None`) : Embedding que contiene señales de condicionamiento para las características del habla.

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

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.

**Devuelve:** `FastSpeech2ConformerModelOutput` o `tuple(torch.Tensor)`

Un `FastSpeech2ConformerModelOutput` 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 ([FastSpeech2ConformerConfig](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) y las entradas.

El método forward de [FastSpeech2ConformerModel](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerModel) 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)`, *opcional*) -- El espectrograma predicho.
- **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*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del 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.
- **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.
- **duration_outputs** (`torch.LongTensor` de forma `(batch_size, max_text_length + 1)`, *opcional*) -- Salidas del predictor de duración.
- **pitch_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Salidas del predictor de tono.
- **energy_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Salidas del predictor de energía.

Ejemplo:

```python
>>> from transformers import (
...     FastSpeech2ConformerTokenizer,
...     FastSpeech2ConformerModel,
...     FastSpeech2ConformerHifiGan,
... )

>>> tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
>>> inputs = tokenizer("some text to convert to speech", return_tensors="pt")
>>> input_ids = inputs["input_ids"]

>>> model = FastSpeech2ConformerModel.from_pretrained("espnet/fastspeech2_conformer")
>>> output_dict = model(input_ids, return_dict=True)
>>> spectrogram = output_dict["spectrogram"]

>>> vocoder = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
>>> waveform = vocoder(spectrogram)
>>> print(waveform.shape)
torch.Size([1, 49664])
```

## FastSpeech2ConformerHifiGan[[transformers.FastSpeech2ConformerHifiGan]]

#### transformers.FastSpeech2ConformerHifiGan[[transformers.FastSpeech2ConformerHifiGan]]

```python
transformers.FastSpeech2ConformerHifiGan(config: FastSpeech2ConformerHifiGanConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1360)

**Parámetros:**

config ([FastSpeech2ConformerHifiGanConfig](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerHifiGanConfig)): clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Vocoder HiFi-GAN.

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

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

#### forward[[transformers.FastSpeech2ConformerHifiGan.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1428)

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

## FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

#### transformers.FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

```python
transformers.FastSpeech2ConformerWithHifiGan(config: FastSpeech2ConformerWithHifiGanConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1483)

**Parámetros:**

config ([FastSpeech2ConformerWithHifiGanConfig](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGanConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El FastSpeech2ConformerModel con una cabeza de vocoder FastSpeech2ConformerHifiGan que realiza la conversión de texto a voz (forma de onda).

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

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

#### forward[[transformers.FastSpeech2ConformerWithHifiGan.forward]]

```python
forward(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, spectrogram_labels: typing.Optional[torch.Tensor] = None, duration_labels: typing.Optional[torch.LongTensor] = None, pitch_labels: typing.Optional[torch.Tensor] = None, energy_labels: typing.Optional[torch.Tensor] = None, speaker_ids: typing.Optional[torch.LongTensor] = None, lang_ids: typing.Optional[torch.LongTensor] = None, speaker_embedding: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1496)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Secuencia de entrada de vectores de texto.

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)

spectrogram_labels (`torch.Tensor` de forma `(batch_size, max_spectrogram_length, num_mel_bins)`, *opcional*, valor predeterminado `None`) : Lote de características objetivo rellenas.

duration_labels (`torch.LongTensor` de forma `(batch_size, sequence_length + 1)`, *opcional*, valor predeterminado `None`) : Lote de duraciones rellenas.

pitch_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, valor predeterminado `None`) : Lote de tono promedio por token con relleno.

energy_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, valor predeterminado `None`) : Lote de energía promedio por token con relleno.

speaker_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, valor predeterminado `None`) : Ids de hablante utilizados para condicionar las características de la salida de voz del modelo.

lang_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, valor predeterminado `None`) : Idiomas utilizados para condicionar las características de la salida de voz del modelo.

speaker_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`, *opcional*, valor predeterminado `None`) : Embedding que contiene señales de condicionamiento para las características del habla.

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

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.

**Devuelve:** `FastSpeech2ConformerModelOutput` o `tuple(torch.Tensor)`

Un `FastSpeech2ConformerModelOutput` 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 ([FastSpeech2ConformerConfig](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) y las entradas.

El método forward de [FastSpeech2ConformerWithHifiGan](/docs/transformers/main/es/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGan) sobrescribe el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de generación de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`, *opcional*) -- El espectrograma predicho.
- **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*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del 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.
- **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.
- **duration_outputs** (`torch.LongTensor` de forma `(batch_size, max_text_length + 1)`, *opcional*) -- Salidas del predictor de duración.
- **pitch_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Salidas del predictor de tono.
- **energy_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Salidas del predictor de energía.

Ejemplo:

```python
>>> from transformers import (
...     FastSpeech2ConformerTokenizer,
...     FastSpeech2ConformerWithHifiGan,
... )

>>> tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
>>> inputs = tokenizer("some text to convert to speech", return_tensors="pt")
>>> input_ids = inputs["input_ids"]

>>> model = FastSpeech2ConformerWithHifiGan.from_pretrained("espnet/fastspeech2_conformer_with_hifigan")
>>> output_dict = model(input_ids, return_dict=True)
>>> waveform = output_dict["waveform"]
>>> print(waveform.shape)
torch.Size([1, 49664])
```