# FastSpeech2Conformer

## Visão geral

O modelo FastSpeech2Conformer foi proposto no artigo [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 e Yuekai Zhang.

O resumo do artigo original FastSpeech2 é o seguinte:

*Modelos de texto para fala (TTS) não autoregressivos, como o FastSpeech (Ren et al., 2019), podem sintetizar fala significativamente mais rápido do que os modelos autoregressivos anteriores, com qualidade comparável. O treinamento do modelo FastSpeech depende de um modelo professor autoregressivo para a previsão de duração (para fornecer mais informações como entrada) e de destilação de conhecimento (para simplificar a distribuição de dados na saída), o que pode facilitar o problema de mapeamento um-para-muitos (ou seja, múltiplas variações de fala correspondem ao mesmo texto) no TTS. No entanto, o FastSpeech apresenta várias desvantagens: 1) o pipeline de destilação professor-aluno é complicado e demorado, 2) a duração extraída do modelo professor não é precisa o suficiente, e os mel-espectrogramas-alvo destilados do modelo professor sofrem com perda de informação devido à simplificação dos dados, ambos os fatores limitam a qualidade da voz. Neste artigo, propomos o FastSpeech 2, que aborda os problemas do FastSpeech e resolve melhor o problema de mapeamento um-para-muitos no TTS por meio de 1) o treinamento direto do modelo com o alvo verdadeiro, em vez da saída simplificada do professor, e 2) a introdução de mais informações de variação da fala (por exemplo, pitch, energia e duração mais precisa) como entradas condicionais. Especificamente, extraímos a duração, o pitch e a energia da forma de onda da fala e os utilizamos diretamente como entradas condicionais no treinamento, usando os valores previstos na inferência. Além disso, projetamos o FastSpeech 2s, que é a primeira tentativa de gerar diretamente a forma de onda da fala a partir do texto em paralelo, aproveitando o benefício da inferência totalmente fim-a-fim. Os resultados experimentais mostram que 1) o FastSpeech 2 alcança uma aceleração de 3x no treinamento em relação ao FastSpeech, e o FastSpeech 2s desfruta de uma velocidade de inferência ainda mais rápida; 2) o FastSpeech 2 e o 2s superam o FastSpeech em qualidade de voz, e o FastSpeech 2 pode até superar os modelos autoregressivos. Amostras de áudio estão disponíveis em https://speechresearch.github.io/fastspeech2/.*

Este modelo foi contribuído por [Connor Henderson](https://huggingface.co/connor-henderson). O código original pode ser encontrado [aqui](https://github.com/espnet/espnet/blob/master/espnet2/tts/fastspeech2/fastspeech2.py).

## 🤗 Arquitetura do Modelo

A estrutura geral do FastSpeech2 com um decodificador de Mel-espectrograma foi implementada, e os blocos de transformer tradicionais foram substituídos por blocos conformer, conforme feito na biblioteca ESPnet.

### Arquitetura do Modelo FastSpeech2

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

#### Blocos 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 Convolução

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

## 🤗 Uso do Transformers

Você pode executar o FastSpeech2Conformer localmente com a biblioteca 🤗 Transformers.

1. Primeiro, instale a biblioteca 🤗 [Transformers](https://github.com/huggingface/transformers) e o g2p-en:

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

2. Execute a inferência por meio do código de modelagem do Transformers com o modelo e o hifigan separadamente

```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. Execute a inferência por meio do código de modelagem do Transformers com o modelo e o 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. Execute inferência com um pipeline e especifique qual 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)
```

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

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

hidden_size (`int`, *opcional*, padrão `384`) : Dimensão das representações ocultas.

vocab_size (`int`, *opcional*, padrão `78`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

num_mel_bins (`int`, *opcional*, padrão `80`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

encoder_num_attention_heads (`int`, *opcional*, padrão 2) : O número de cabeças de atenção no codificador.

encoder_layers (`int`, *opcional*, padrão `4`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

encoder_linear_units (`int`, *opcional*, padrão 1536) : O número de unidades na camada linear do codificador.

decoder_layers (`int`, *opcional*, padrão `4`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

decoder_num_attention_heads (`int`, *opcional*, padrão `2`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

decoder_linear_units (`int`, *opcional*, padrão 1536) : O número de unidades na camada linear do decodificador.

speech_decoder_postnet_layers (`int`, *opcional*, padrão 5) : O número de camadas na pós-rede do decodificador de fala.

speech_decoder_postnet_units (`int`, *opcional*, padrão 256) : O número de unidades nas camadas da pós-rede do decodificador de fala.

speech_decoder_postnet_kernel (`int`, *opcional*, padrão 5) : O tamanho do kernel na pós-rede do decodificador de fala.

positionwise_conv_kernel_size (`int`, *opcional*, padrão 3) : O tamanho do núcleo de convolução usado na camada posicional.

encoder_normalize_before (`bool`, *opcional*, padrão `False`) : Especifica se a normalização deve ser aplicada antes das camadas do codificador.

decoder_normalize_before (`bool`, *opcional*, padrão `False`) : Especifica se a normalização deve ser aplicada antes das camadas do decodificador.

encoder_concat_after (`bool`, *opcional*, padrão `False`) : Especifica se deve concatenar após as camadas do codificador.

decoder_concat_after (`bool`, *opcional*, padrão `False`) : Especifica se deve concatenar após as camadas do decodificador.

reduction_factor (`int`, *opcional*, padrão 1) : O fator pelo qual a taxa de quadros da fala é reduzida.

speaking_speed (`float`, *opcional*, padrão 1.0) : A velocidade da fala produzida.

use_macaron_style_in_conformer (`bool`, *opcional*, padrão `True`) : Especifica se deve usar o estilo macaron no conformer.

use_cnn_in_conformer (`bool`, *opcional*, padrão `True`) : Especifica se as redes neurais convolucionais devem ser usadas no conformer.

encoder_kernel_size (`int`, *opcional*, padrão 7) : O tamanho do kernel usado no codificador.

decoder_kernel_size (`int`, *opcional*, padrão 31) : O tamanho do kernel usado no decodificador.

duration_predictor_layers (`int`, *opcional*, padrão 2) : O número de camadas no preditor de duração.

duration_predictor_channels (`int`, *opcional*, padrão 256) : O número de canais no preditor de duração.

duration_predictor_kernel_size (`int`, *opcional*, padrão 3) : O tamanho do kernel usado no preditor de duração.

energy_predictor_layers (`int`, *opcional*, padrão 2) : O número de camadas no preditor de energia.

energy_predictor_channels (`int`, *opcional*, padrão 256) : O número de canais no preditor de energia.

energy_predictor_kernel_size (`int`, *opcional*, padrão 3) : O tamanho do kernel usado no preditor de energia.

energy_predictor_dropout (`float`, *opcional*, padrão 0.5) : A taxa de dropout no preditor de energia.

energy_embed_kernel_size (`int`, *opcional*, padrão 1) : O tamanho do kernel usado na camada de incorporação de energia.

energy_embed_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout na camada de incorporação de energia.

stop_gradient_from_energy_predictor (`bool`, *opcional*, padrão `False`) : Especifica se deve interromper os gradientes do preditor de energia.

pitch_predictor_layers (`int`, *opcional*, padrão 5) : O número de camadas no preditor de pitch.

pitch_predictor_channels (`int`, *opcional*, padrão 256) : O número de canais no preditor de pitch.

pitch_predictor_kernel_size (`int`, *opcional*, padrão 5) : O tamanho do kernel usado no preditor de pitch.

pitch_predictor_dropout (`float`, *opcional*, padrão 0.5) : A taxa de dropout no preditor de pitch.

pitch_embed_kernel_size (`int`, *opcional*, padrão 1) : O tamanho do kernel usado na camada de incorporação de pitch.

pitch_embed_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout na camada de incorporação de pitch.

stop_gradient_from_pitch_predictor (`bool`, *opcional*, padrão `True`) : Especifica se deve interromper os gradientes do preditor de tom.

encoder_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout no codificador.

encoder_positional_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout posicional no codificador.

encoder_attention_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout de atenção no codificador.

decoder_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout no decodificador.

decoder_positional_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout posicional no decodificador.

decoder_attention_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout de atenção no decodificador.

duration_predictor_dropout_rate (`float`, *opcional*, padrão 0.2) : A taxa de dropout no preditor de duração.

speech_decoder_postnet_dropout (`float`, *opcional*, padrão 0.5) : A taxa de dropout no postnet do decodificador de fala.

max_source_positions (`int`, *opcional*, padrão 5000) : se os embeddings de posição `"relative"` forem usados, define as posições máximas de entrada da fonte.

use_masking (`bool`, *opcional*, padrão `True`) : Especifica se deve usar mascaramento no modelo.

use_weighted_masking (`bool`, *opcional*, padrão `False`) : Especifica se deve usar mascaramento ponderado no modelo.

num_speakers (`int`, *opcional*) : Número de falantes. Se definido como > 1, assume que os ids de falante serão fornecidos como entrada e usa a camada de incorporação de id de falante.

num_languages (`int`, *opcional*) : Número de idiomas. Se definido como > 1, assume que os ids de idioma serão fornecidos como entrada e usa a camada de incorporação de id de idioma.

speaker_embed_dim (`int`, *opcional*) : Dimensão do embedding de falante. Se definido como > 0, assume-se que speaker_embedding será fornecido como entrada.

convolution_bias (`bool`, *opcional*, padrão `True`) : Especifica se deve usar viés nas convoluções do módulo de convolução do conformer.

Esta é a classe de configuração para armazenar a configuração de um FastSpeech2ConformerModel. Ela é usada para instanciar um modelo Fastspeech2 Conformer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [espnet/fastspeech2_conformer](https://huggingface.co/espnet/fastspeech2_conformer)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

model_in_dim (`int`, *opcional*, padrão 80) : O número de bins de frequência no espectrograma log-mel de entrada.

upsample_initial_channel (`int`, *opcional*, padrão 512) : O número de canais de entrada para a rede de upsampling.

upsample_rates (`tuple[int]` ou `list[int]`, *opcional*, padrão `[8, 8, 2, 2]`) : Uma tupla de inteiros que define o stride de cada camada convolucional 1D na rede de upsampling. O comprimento de *upsample_rates* define o número de camadas convolucionais e deve corresponder ao comprimento de *upsample_kernel_sizes*.

upsample_kernel_sizes (`tuple[int]` ou `list[int]`, *opcional*, padrão `[16, 16, 4, 4]`) : Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D na rede de upsampling. O comprimento de *upsample_kernel_sizes* define o número de camadas convolucionais e deve corresponder ao comprimento de *upsample_rates*.

resblock_kernel_sizes (`tuple[int]` ou `list[int]`, *opcional*, padrão `[3, 7, 11]`) : Uma tupla de inteiros que define os tamanhos dos kernels das camadas convolucionais 1D no módulo de fusão de múltiplos campos receptivos (MRF).

resblock_dilation_sizes (`tuple[tuple[int]]` ou `list[list[int]]`, *opcional*, padrão `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Uma tupla aninhada de inteiros que define as taxas de dilatação das camadas de convolução 1D dilataadas no módulo de fusão de múltiplos campos receptivos (MRF).

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

leaky_relu_slope (`float`, *opcional*, padrão 0.1) : O ângulo da inclinação negativa usado pela ativação leaky ReLU.

normalize_before (`bool`, *opcional*, padrão `True`) : Indica se a espectrograma deve ser normalizada antes da vocodificação, utilizando a média e a variância aprendidas pelo vocoder.

Esta é a classe de configuração para armazenar a configuração de um FastSpeech2ConformerModel. Ela é usada para instanciar um modelo Fastspeech2 Conformer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

model_config (`FastSpeech2ConformerConfig | dict`, *opcional*) : Configuração do modelo de texto para fala.

vocoder_config (`FastSpeech2ConformerHiFiGanConfig | dict`, *opcional*) : Configuração do modelo vocoder.

Esta é a classe de configuração para armazenar a configuração de um FastSpeech2ConformerModel. Ela é usada para instanciar um modelo Fastspeech2 Conformer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

vocab_file (`str`) : Caminho para o arquivo de vocabulário.

bos_token (`str`, *opcional*, padrão `"<sos/eos>"`) : O token de início de sequência. Observe que, para o FastSpeech2, ele é o mesmo que o `eos_token`.

eos_token (`str`, *opcional*, padrão `"<sos/eos>"`) : O token de fim de sequência. Observe que, para o FastSpeech2, ele é o mesmo que o `bos_token`.

pad_token (`str`, *opcional*, padrão `"<blank>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.

unk_token (`str`, *opcional*, padrão `"<unk>"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

should_strip_spaces (`bool`, *opcional*, padrão `False`) : Indica se os espaços devem ser removidos da lista de tokens.

Construa um tokenizer FastSpeech2Conformer.

#### __call__[[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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)

**Parâmetros:**

text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).

text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências).

tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência.

add_special_tokens (`bool`, *opcional*, padrão `True`) : Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar automaticamente tokens `bos` ou `eos`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.

stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. O valor deste argumento define o número de tokens sobrepostos.

is_split_into_words (`bool`, *opcional*, padrão `False`) : Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como `True`, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokenizará. Isso é útil para NER ou classificação de tokens.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que `padding` esteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta).

padding_side (`str`, *opcional*) : O lado em que o modelo deve ter padding aplicado. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes.

return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais.

return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`.

return_length  (`bool`, *opcional*, padrão `False`) : Indica se as comprimentos das entradas codificadas devem ser retornados.

verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos.

- ****kwargs** : passados para o método `self.tokenize()`

**Retorna:** [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding)

Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) com os seguintes campos:

- **input_ids** -- Lista de ids de tokens a serem fornecidos a um modelo.

  [O que são IDs de entrada?](../glossary#input-ids)

- **token_type_ids** -- Lista de ids de tipo de token a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"token_type_ids"* estiver em `self.model_input_names`).

  [O que são IDs de tipo de token?](../glossary#token-type-ids)

- **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando `return_attention_mask=True` ou se *"attention_mask"* estiver em `self.model_input_names`).

  [O que são máscaras de atenção?](../glossary#attention-mask)

- **overflowing_tokens** -- Lista de sequências de tokens excedentes (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Número de tokens truncados (quando um `max_length` é especificado e `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando `add_special_tokens=True` e `return_special_tokens_mask=True`).
- **length** -- O comprimento das entradas (quando `return_length=True`)

Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo.

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

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

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

**Parâmetros:**

save_directory (`str`) : O diretório em que salvar o vocabulário.

**Retorna:** `Tuple(str)`

Caminhos para os arquivos salvos.

Salve o arquivo de vocabulário e tokens especiais em um diretório.

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

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

[Origem](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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2933)

**Parâmetros:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`.

skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação.

clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização. Se `None`, o padrão será `self.clean_up_tokenization_spaces`.

kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente.

**Retorna:** `list[str]`

A lista de frases decodificadas.

Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.

Este método é fornecido para compatibilidade reversa. O método `decode` agora processa entradas em lote nativamente, portanto, você pode usar `decode` diretamente em vez de `batch_decode`.

## FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

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

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

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

**Parâmetros:**

config ([FastSpeech2ConformerConfig](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo FastSpeech2Conformer.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](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)`) : Sequência de entrada de vetores de texto.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor` de forma `(batch_size, max_spectrogram_length, num_mel_bins)`, *opcional*, padrão `None`) : Lote de recursos de destino com preenchimento.

duration_labels (`torch.LongTensor` de forma `(batch_size, sequence_length + 1)`, *opcional*, padrão `None`) : Lote de durações com preenchimento.

pitch_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, padrão `None`) : Lote de pitch médio por token, com preenchimento.

energy_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, padrão `None`) : Lote de energia média por token com preenchimento.

speaker_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, padrão `None`) : IDs de falante usados para condicionar os recursos da saída de fala do modelo.

lang_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, padrão `None`) : IDs de idioma usados para condicionar os recursos da saída de fala pelo modelo.

speaker_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`, *opcional*, padrão `None`) : Incorporação contendo sinais de condicionamento para os recursos da fala.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

**Retorna:** `FastSpeech2ConformerModelOutput` ou `tuple(torch.Tensor)`

Um `FastSpeech2ConformerModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([FastSpeech2ConformerConfig](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) e das entradas.

O método forward do [FastSpeech2ConformerModel](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de geração de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`, *opcional*) -- O espectrograma previsto.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **duration_outputs** (`torch.LongTensor` de forma `(batch_size, max_text_length + 1)`, *opcional*) -- Saídas do preditor de duração.
- **pitch_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Saídas do preditor de pitch.
- **energy_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Saídas do preditor de energia.

Exemplo:

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

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

**Parâmetros:**

config ([FastSpeech2ConformerHifiGanConfig](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerHifiGanConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Vocoder HiFi-GAN.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

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

**Parâmetros:**

spectrogram (`torch.Tensor`) : Tensor contendo os espectrogramas log-mel. Pode ser em lote (batched) e ter a forma `(batch_size, sequence_length, config.model_in_dim)`, ou sem lote (un-batched) e ter a forma `(sequence_length, config.model_in_dim)`.

**Retorna:** `torch.Tensor`

Tensor contendo a forma de onda da fala. Se o espectrograma de entrada estiver em lote, terá a forma `(batch_size, num_frames,)`. Se não estiver em lote, terá a forma `(num_frames,)`.

Converte um espectrograma log-mel em uma forma de onda de fala. Ao passar um lote de espectrogramas log-mel, retorna um lote de formas de onda de fala. Ao passar um único espectrograma log-mel, sem lote, retorna uma única forma de onda de fala, sem lote.

## FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

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

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

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

**Parâmetros:**

config ([FastSpeech2ConformerWithHifiGanConfig](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGanConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O FastSpeech2ConformerModel com uma cabeça de vocoder FastSpeech2ConformerHifiGan que executa a conversão de texto em fala (forma de onda).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](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)`) : Sequência de entrada de vetores de texto.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor` de forma `(batch_size, max_spectrogram_length, num_mel_bins)`, *opcional*, padrão `None`) : Lote de recursos de destino com preenchimento.

duration_labels (`torch.LongTensor` de forma `(batch_size, sequence_length + 1)`, *opcional*, padrão `None`) : Lote de durações com preenchimento.

pitch_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, padrão `None`) : Lote de pitch médio por token, com preenchimento.

energy_labels (`torch.Tensor` de forma `(batch_size, sequence_length + 1, 1)`, *opcional*, padrão `None`) : Lote de energia média por token com preenchimento.

speaker_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, padrão `None`) : IDs de falante usados para condicionar os recursos da saída de fala do modelo.

lang_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*, padrão `None`) : IDs de idioma usados para condicionar os recursos da saída de fala pelo modelo.

speaker_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`, *opcional*, padrão `None`) : Incorporação contendo sinais de condicionamento para os recursos da fala.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

**Retorna:** `FastSpeech2ConformerModelOutput` ou `tuple(torch.Tensor)`

Um `FastSpeech2ConformerModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([FastSpeech2ConformerConfig](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) e das entradas.

O método forward de [FastSpeech2ConformerWithHifiGan](/docs/transformers/main/pt/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGan) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de geração de espectrograma.
- **espectrograma** (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`, *opcional*) -- O espectrograma previsto.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **duration_outputs** (`torch.LongTensor` de forma `(batch_size, max_text_length + 1)`, *opcional*) -- Saídas do preditor de duração.
- **pitch_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Saídas do preditor de pitch.
- **energy_outputs** (`torch.Tensor` de forma `(batch_size, max_text_length + 1, 1)`, *opcional*) -- Saídas do preditor de energia.

Exemplo:

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