# FastSpeech2Conformer

## Ikhtisar

Model FastSpeech2Conformer diusulkan melalui makalah [Recent Developments On Espnet Toolkit Boosted By Conformer](https://huggingface.co/papers/2010.13956) oleh 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, dan Yuekai Zhang.

Abstrak dari paper FastSpeech2 asli adalah sebagai berikut:

*Model text-to-speech (TTS) non-otoregresif seperti FastSpeech (Ren et al., 2019) dapat mensintesis ucapan secara signifikan lebih cepat daripada model otoregresif sebelumnya dengan kualitas yang sebanding. Pelatihan model FastSpeech bergantung pada model guru otoregresif untuk prediksi durasi (untuk menyediakan lebih banyak informasi sebagai input) dan distilasi pengetahuan (untuk menyederhanakan distribusi data pada output), yang dapat memitigasi masalah pemetaan satu-ke-banyak (yaitu, beberapa variasi ucapan berkorespondensi dengan teks yang sama) dalam TTS. Namun, FastSpeech memiliki beberapa kelemahan: 1) pipeline distilasi guru-murid yang rumit dan memakan waktu, 2) durasi yang diekstrak dari model guru tidak cukup akurat, dan mel-spektrogram target yang didistilasi dari model guru mengalami kehilangan informasi akibat penyederhanaan data, keduanya membatasi kualitas suara. Dalam makalah ini, kami mengusulkan FastSpeech 2, yang mengatasi masalah pada FastSpeech dan lebih baik menyelesaikan masalah pemetaan satu-ke-banyak dalam TTS dengan 1) melatih model secara langsung dengan target ground-truth alih-alih output yang disederhanakan dari guru, dan 2) memperkenalkan lebih banyak informasi variasi ucapan (misalnya, pitch, energi, dan durasi yang lebih akurat) sebagai input kondisional. Secara spesifik, kami mengekstrak durasi, pitch, dan energi dari waveform ucapan dan langsung menggunakannya sebagai input kondisional dalam pelatihan serta menggunakan nilai prediksi dalam inferensi. Kami juga merancang FastSpeech 2s, yang merupakan upaya pertama untuk menghasilkan waveform ucapan secara langsung dari teks secara paralel, menikmati keuntungan dari inferensi end-to-end penuh. Hasil eksperimen menunjukkan bahwa 1) FastSpeech 2 mencapai percepatan pelatihan 3x dibandingkan FastSpeech, dan FastSpeech 2s menikmati kecepatan inferensi yang bahkan lebih cepat; 2) FastSpeech 2 dan 2s melampaui FastSpeech dalam kualitas suara, dan FastSpeech 2 bahkan dapat melampaui model otoregresif. Contoh audio tersedia di https://speechresearch.github.io/fastspeech2/.*

Model ini disumbangkan oleh [Connor Henderson](https://huggingface.co/connor-henderson). Kode aslinya dapat ditemukan [di sini](https://github.com/espnet/espnet/blob/master/espnet2/tts/fastspeech2/fastspeech2.py).

## 🤗 Arsitektur Model

Struktur umum FastSpeech2 dengan dekodeur Mel-spectrogram diimplementasikan, dan blok transformer tradisional diganti dengan blok conformer sebagaimana dilakukan di pustaka ESPnet.

### Arsitektur Model FastSpeech2

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

#### Blok Conformer

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

#### Modul Konvolusi

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

## 🤗 Penggunaan Transformers

Anda dapat menjalankan FastSpeech2Conformer secara lokal dengan pustaka 🤗 Transformers.

1. Pertama, instal [library Transformers](https://github.com/huggingface/transformers) 🤗, g2p-en:

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

2. Jalankan inferensi melalui kode pemodelan Transformers dengan model dan hifigan secara terpisah

```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. Jalankan inferensi melalui kode pemodelan Transformers dengan model dan hifigan yang digabungkan

```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. Jalankan inferensi dengan pipeline dan tentukan vocoder yang akan digunakan

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

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

**Parameter:**

is_encoder_decoder (`bool`, *opsional*, defaultnya `True`) : Apakah model digunakan sebagai encoder/decoder atau tidak.

hidden_size (`int`, *opsional*, defaultnya `384`) : Dimensi dari representasi tersembunyi.

vocab_size (`int`, *opsional*, defaultnya `78`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

num_mel_bins (`int`, *opsional*, defaultnya `80`) : Jumlah fitur mel yang digunakan per bingkai input. Seharusnya sesuai dengan nilai yang digunakan di kelas `AutoFeatureExtractor`.

encoder_num_attention_heads (`int`, *opsional*, defaultnya 2) : Jumlah kepala perhatian (attention heads) dalam encoder.

encoder_layers (`int`, *opsional*, defaultnya `4`) : Jumlah lapisan tersembunyi dalam encoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

encoder_linear_units (`int`, *opsional*, default 1536) : Jumlah unit pada lapisan linear dari encoder.

decoder_layers (`int`, *opsional*, defaultnya `4`) : Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

decoder_num_attention_heads (`int`, *opsional*, defaultnya `2`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

decoder_linear_units (`int`, *opsional*, default 1536) : Jumlah unit pada lapisan linear dari decoder.

speech_decoder_postnet_layers (`int`, *opsional*, defaultnya 5) : Jumlah lapisan dalam post-net dari decoder ucapan.

speech_decoder_postnet_units (`int`, *opsional*, default 256) : Jumlah unit di lapisan post-net dari decoder ucapan.

speech_decoder_postnet_kernel (`int`, *opsional*, defaultnya 5) : Ukuran kernel di post-net dari decoder ucapan.

positionwise_conv_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel konvolusi yang digunakan pada lapisan posisi-tertentu.

encoder_normalize_before (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan menormalisasi sebelum lapisan encoder.

decoder_normalize_before (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan menormalisasi sebelum lapisan decoder.

encoder_concat_after (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan melakukan penggabungan (concatenate) setelah lapisan encoder.

decoder_concat_after (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan melakukan penggabungan (concatenate) setelah lapisan decoder.

reduction_factor (`int`, *opsional*, default 1) : Faktor pengurangan laju bingkai ucapan.

speaking_speed (`float`, *opsional*, default 1.0) : Kecepatan ucapan yang dihasilkan.

use_macaron_style_in_conformer (`bool`, *opsional*, defaultnya `True`) : Menentukan apakah akan menggunakan gaya macaron dalam conformer.

use_cnn_in_conformer (`bool`, *opsional*, defaultnya `True`) : Menentukan apakah jaringan saraf konvolusional akan digunakan dalam conformer.

encoder_kernel_size (`int`, *opsional*, defaultnya 7) : Ukuran kernel yang digunakan dalam encoder.

decoder_kernel_size (`int`, *opsional*, defaultnya 31) : Ukuran kernel yang digunakan dalam decoder.

duration_predictor_layers (`int`, *opsional*, defaultnya 2) : Jumlah lapisan dalam duration predictor.

duration_predictor_channels (`int`, *opsional*, defaultnya 256) : Jumlah channel dalam duration predictor.

duration_predictor_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel yang digunakan dalam duration predictor.

energy_predictor_layers (`int`, *opsional*, defaultnya 2) : Jumlah lapisan dalam prediktor energi.

energy_predictor_channels (`int`, *opsional*, default 256) : Jumlah channel dalam prediktor energi.

energy_predictor_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel yang digunakan dalam prediktor energi.

energy_predictor_dropout (`float`, *opsional*, default 0.5) : Tingkat dropout pada prediktor energi.

energy_embed_kernel_size (`int`, *opsional*, default 1) : Ukuran kernel yang digunakan pada lapisan energy embed.

energy_embed_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout pada lapisan energy embed.

stop_gradient_from_energy_predictor (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan menghentikan gradien dari prediktor energi.

pitch_predictor_layers (`int`, *opsional*, defaultnya 5) : Jumlah lapisan dalam prediktor pitch.

pitch_predictor_channels (`int`, *opsional*, default 256) : Jumlah channel dalam pitch predictor.

pitch_predictor_kernel_size (`int`, *opsional*, defaultnya 5) : Ukuran kernel yang digunakan dalam prediktor pitch.

pitch_predictor_dropout (`float`, *opsional*, default 0.5) : Tingkat dropout pada prediktor pitch.

pitch_embed_kernel_size (`int`, *opsional*, default 1) : Ukuran kernel yang digunakan di lapisan pitch embed.

pitch_embed_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout pada lapisan embed pitch.

stop_gradient_from_pitch_predictor (`bool`, *opsional*, defaultnya `True`) : Menentukan apakah gradien dari prediktor pitch akan dihentikan.

encoder_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout pada encoder.

encoder_positional_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout posisional di encoder.

encoder_attention_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout perhatian di encoder.

decoder_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout di decoder.

decoder_positional_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout posisional di decoder.

decoder_attention_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout perhatian di decoder.

duration_predictor_dropout_rate (`float`, *opsional*, default 0.2) : Tingkat dropout pada duration predictor.

speech_decoder_postnet_dropout (`float`, *opsional*, default 0.5) : Tingkat dropout pada postnet decoder ucapan.

max_source_positions (`int`, *opsional*, defaultnya 5000) : jika `"relative"` position embeddings digunakan, mendefinisikan posisi input sumber maksimum.

use_masking (`bool`, *opsional*, defaultnya `True`) : Menentukan apakah masking akan digunakan dalam model.

use_weighted_masking (`bool`, *opsional*, defaultnya `False`) : Menentukan apakah akan menggunakan masking berbobot dalam model.

num_speakers (`int`, *opsional*) : Jumlah pembicara. Jika diatur ke > 1, asumsikan bahwa id pembicara akan diberikan sebagai input dan gunakan lapisan embedding id pembicara.

num_languages (`int`, *opsional*) : Jumlah bahasa. Jika diatur ke > 1, asumsikan bahwa id bahasa akan diberikan sebagai input dan gunakan lapisan embedding id bahasa.

speaker_embed_dim (`int`, *opsional*) : Dimensi embedding pembicara. Jika diset ke > 0, diasumsikan bahwa speaker_embedding akan disediakan sebagai input.

convolution_bias (`bool`, *opsional*, defaultnya `True`) : Menentukan apakah bias akan digunakan dalam konvolusi pada modul konvolusi conformer.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FastSpeech2ConformerModel. Kelas ini digunakan untuk membuat instans model Fastspeech2 Conformer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [espnet/fastspeech2_conformer](https://huggingface.co/espnet/fastspeech2_conformer)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

model_in_dim (`int`, *opsional*, defaultnya 80) : Jumlah bin frekuensi dalam spektrogram log-mel input.

upsample_initial_channel (`int`, *opsional*, defaultnya 512) : Jumlah saluran input ke jaringan upsampling.

upsample_rates (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[8, 8, 2, 2]`) : Tuple dari bilangan bulat yang mendefinisikan stride dari setiap lapisan konvolusional 1D dalam jaringan upsampling. Panjang dari *upsample_rates* mendefinisikan jumlah lapisan konvolusional dan harus sesuai dengan panjang dari *upsample_kernel_sizes*.

upsample_kernel_sizes (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[16, 16, 4, 4]`) : Tuple dari bilangan bulat yang mendefinisikan ukuran kernel dari setiap lapisan konvolusional 1D dalam jaringan upsampling. Panjang dari *upsample_kernel_sizes* mendefinisikan jumlah lapisan konvolusional dan harus sesuai dengan panjang dari *upsample_rates*.

resblock_kernel_sizes (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[3, 7, 11]`) : Tuple bilangan bulat yang mendefinisikan ukuran kernel dari lapisan konvolusional 1D dalam modul multi-receptive field fusion (MRF).

resblock_dilation_sizes (`tuple[tuple[int]]` atau `list[list[int]]`, *opsional*, defaultnya `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Tuple bersarang dari bilangan bulat yang mendefinisikan laju dilatasi dari lapisan konvolusi 1D yang didilatasi dalam modul fusi multi-receptive field (MRF).

initializer_range (`float`, *opsional*, defaultnya `0.01`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

leaky_relu_slope (`float`, *opsional*, default 0.1) : Sudut kemiringan negatif yang digunakan oleh aktivasi leaky ReLU.

normalize_before (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi spektrogram sebelum vokoding menggunakan rata-rata dan varians yang dipelajari oleh vokoder.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FastSpeech2ConformerModel. Kelas ini digunakan untuk membuat instans model Fastspeech2 Conformer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

model_config (`FastSpeech2ConformerConfig | dict`, *optional*) : Configuration of the text-to-speech model.

vocoder_config (`FastSpeech2ConformerHiFiGanConfig | dict`, *opsional*) : Konfigurasi model vocoder.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari FastSpeech2ConformerModel. Kelas ini digunakan untuk membuat instans model Fastspeech2 Conformer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

vocab_file (`str`) : Path ke file kosakata.

bos_token (`str`, *opsional*, defaultnya `"<sos/eos>"`) : Token awal urutan. Perhatikan bahwa untuk FastSpeech2, token ini sama dengan `eos_token`.

eos_token (`str`, *opsional*, defaultnya `"<sos/eos>"`) : Token akhir urutan. Perhatikan bahwa untuk FastSpeech2, token ini sama dengan `bos_token`.

pad_token (`str`, *opsional*, defaultnya `"<blank>"`) : Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda.

unk_token (`str`, *opsional*, defaultnya `"<unk>"`) : Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini.

should_strip_spaces (`bool`, *opsional*, defaultnya `False`) : Apakah akan menghapus spasi dari daftar token.

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

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

**Parameter:**

text (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

tokenizer_kwargs (`dict[str, Any]`, *opsional*) : kwargs tambahan untuk diteruskan ke tokenizer. Nilai-nilai ini akan digabungkan dengan parameter eksplisit dan kwargs lainnya, dengan parameter eksplisit memiliki prioritas lebih tinggi.

add_special_tokens (`bool`, *opsional*, default `True`) : Menentukan apakah token khusus akan ditambahkan saat meng-encode urutan. Hal ini akan menggunakan fungsi `PretrainedTokenizerBase.build_inputs_with_special_tokens` yang mendasarinya, yang mendefinisikan token apa saja yang secara otomatis ditambahkan ke input ids. Ini berguna jika Anda ingin menambahkan token `bos` atau `eos` secara otomatis.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/main/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/main/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

stride (`int`, *opsional*, default 0) : Jika diatur ke sebuah angka bersamaan dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan memuat beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.

is_split_into_words (`bool`, *opsional*, default `False`) : Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata-kata). Jika disetel ke `True`, tokenizer mengasumsikan input sudah dipecah menjadi kata-kata (misalnya, dengan memisahkannya berdasarkan spasi) yang kemudian akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, sekuens akan di-*pad* menjadi kelipatan dari nilai yang diberikan. Memerlukan `padding` untuk diaktifkan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta).

padding_side (`str`, *opsional*) : Sisi tempat model harus menerapkan padding. Harus dipilih dari ['right', 'left']. Nilai default diambil dari atribut kelas dengan nama yang sama.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor alih-alih daftar bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

return_token_type_ids (`bool`, *opsional*) : Apakah akan mengembalikan token type ID. Jika dibiarkan pada nilai default, akan mengembalikan token type ID sesuai default tokenizer tertentu, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu token type ID?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, attention mask akan dikembalikan sesuai dengan default tokenizer yang bersangkutan, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu attention mask?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan urutan token yang meluap. Jika sepasang urutan id input (atau batch dari pasangan) diberikan dengan `truncation_strategy = longest_first` atau `True`, error akan dilemparkan alih-alih mengembalikan token yang meluap.

return_special_tokens_mask (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan informasi mask token khusus.

return_offsets_mapping (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan `(char_start, char_end)` untuk setiap token. Ini hanya tersedia pada fast tokenizer yang mewarisi dari [PreTrainedTokenizerFast](/docs/transformers/main/id/main_classes/tokenizer#transformers.TokenizersBackend); jika menggunakan tokenizer Python, metode ini akan melempar `NotImplementedError`.

return_length  (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan panjang dari input yang dikodekan.

verbose (`bool`, *opsional*, default `True`) : Apakah akan mencetak informasi dan peringatan yang lebih banyak.

- ****kwargs** : diteruskan ke metode `self.tokenize()`

**Mengembalikan:** [BatchEncoding](/docs/transformers/main/id/main_classes/tokenizer#transformers.BatchEncoding)

[BatchEncoding](/docs/transformers/main/id/main_classes/tokenizer#transformers.BatchEncoding) dengan bidang berikut:

- **input_ids** -- Daftar id token yang akan diberikan ke model.

  [Apa itu input ID?](../glossary#input-ids)

- **token_type_ids** -- Daftar token type id yang akan diberikan ke model (ketika `return_token_type_ids=True` atau jika *"token_type_ids"* ada di `self.model_input_names`).

  [Apa itu token type ID?](../glossary#token-type-ids)

- **attention_mask** -- Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika `return_attention_mask=True` atau jika *"attention_mask"* ada di `self.model_input_names`).

  [Apa itu attention mask?](../glossary#attention-mask)

- **overflowing_tokens** -- Daftar sekuens token yang meluap (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Jumlah token yang dipangkas (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Daftar angka 0 dan 1, di mana 1 menandakan token khusus yang ditambahkan dan 0 menandakan token urutan reguler (ketika `add_special_tokens=True` dan `return_special_tokens_mask=True`).
- **length** -- Panjang dari input (ketika `return_length=True`)

Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa urutan, atau satu atau beberapa pasangan urutan, untuk model.

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

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

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

**Parameter:**

save_directory (`str`) : Direktori tempat menyimpan kosa kata.

**Mengembalikan:** `Tuple(str)`

Path ke file yang disimpan.

Simpan file kosakata dan token khusus ke sebuah direktori.

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

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

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

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

**Parameter:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Daftar id input yang telah ditokenisasi. Dapat diperoleh menggunakan metode `__call__`.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi tokenisasi atau tidak. Jika `None`, akan menggunakan nilai default `self.clean_up_tokenization_spaces`.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode decode spesifik model yang mendasarinya.

**Mengembalikan:** `list[str]`

Daftar kalimat yang telah didekode.

Konversi daftar dari daftar id token menjadi daftar string dengan memanggil decode.

Metode ini disediakan untuk kompatibilitas mundur. Metode `decode` sekarang menangani input berbatch secara native, sehingga Anda dapat menggunakan `decode` secara langsung alih-alih `batch_decode`.

## FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

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

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

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

**Parameter:**

config ([FastSpeech2ConformerConfig](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model FastSpeech2Conformer.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Urutan input dari vektor teks.

attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor` dengan bentuk `(batch_size, max_spectrogram_length, num_mel_bins)`, *opsional*, default `None`) : Batch dari fitur target yang di-pad.

duration_labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length + 1)`, *opsional*, defaultnya `None`) : Batch durasi yang di-pad.

pitch_labels (`torch.Tensor` dengan bentuk `(batch_size, sequence_length + 1, 1)`, *opsional*, default `None`) : Batch dari pitch rata-rata token yang di-pad.

energy_labels (`torch.Tensor` dengan bentuk `(batch_size, sequence_length + 1, 1)`, *opsional*, default `None`) : Batch dari energi rata-rata token yang di-pad.

speaker_ids (`torch.LongTensor` dengan bentuk `(batch_size, 1)`, *opsional*, defaultnya `None`) : ID pembicara yang digunakan untuk mengondisikan fitur output ucapan oleh model.

lang_ids (`torch.LongTensor` dengan bentuk `(batch_size, 1)`, *opsional*, defaultnya `None`) : ID bahasa yang digunakan untuk mengondisikan fitur output ucapan oleh model.

speaker_embedding (`torch.Tensor` dengan bentuk `(batch_size, embedding_dim)`, *opsional*, default `None`) : Embedding yang berisi sinyal kondisioning untuk fitur dari ucapan.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

**Mengembalikan:** `FastSpeech2ConformerModelOutput` atau `tuple(torch.Tensor)`

A `FastSpeech2ConformerModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([FastSpeech2ConformerConfig](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) dan input.

Metode forward dari [FastSpeech2ConformerModel](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss untuk generasi spektrogram.
- **spectrogram** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, num_bins)`, *opsional*) -- Spektrogram yang diprediksi.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states dari encoder pada output setiap layer ditambah output embedding awal.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states dari decoder pada output setiap layer ditambah output embedding awal.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **duration_outputs** (`torch.LongTensor` dengan bentuk `(batch_size, max_text_length + 1)`, *opsional*) -- Output dari duration predictor.
- **pitch_outputs** (`torch.Tensor` dengan bentuk `(batch_size, max_text_length + 1, 1)`, *opsional*) -- Output dari prediktor pitch.
- **energy_outputs** (`torch.Tensor` dengan bentuk `(batch_size, max_text_length + 1, 1)`, *opsional*) -- Output dari prediktor energi.

Contoh:

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

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

**Parameter:**

config ([FastSpeech2ConformerHifiGanConfig](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerHifiGanConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Vocoder HiFi-GAN.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

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

**Parameter:**

spectrogram (`torch.Tensor`) : Tensor yang berisi log-mel spectrograms. Dapat di-batch dengan bentuk `(batch_size, sequence_length, config.model_in_dim)`, atau tanpa batch dengan bentuk `(sequence_length, config.model_in_dim)`.

**Mengembalikan:** `torch.Tensor`

Tensor yang berisi waveform ucapan. Jika spektrogram input di-batch, bentuknya akan menjadi `(batch_size, num_frames,)`. Jika tidak di-batch, bentuknya akan menjadi `(num_frames,)`.

Mengonversi log-mel spectrogram menjadi waveform ucapan. Mengirimkan batch log-mel spectrogram mengembalikan batch waveform ucapan. Mengirimkan log-mel spectrogram tunggal, tanpa batch, mengembalikan waveform ucapan tunggal, tanpa batch.

## FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

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

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

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

**Parameter:**

config ([FastSpeech2ConformerWithHifiGanConfig](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGanConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

The FastSpeech2ConformerModel dengan kepala vocoder FastSpeech2ConformerHifiGan yang melakukan text-to-speech (waveform).

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Urutan input dari vektor teks.

attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor` dengan bentuk `(batch_size, max_spectrogram_length, num_mel_bins)`, *opsional*, default `None`) : Batch dari fitur target yang di-pad.

duration_labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length + 1)`, *opsional*, defaultnya `None`) : Batch durasi yang di-pad.

pitch_labels (`torch.Tensor` dengan bentuk `(batch_size, sequence_length + 1, 1)`, *opsional*, default `None`) : Batch dari pitch rata-rata token yang di-pad.

energy_labels (`torch.Tensor` dengan bentuk `(batch_size, sequence_length + 1, 1)`, *opsional*, default `None`) : Batch dari energi rata-rata token yang di-pad.

speaker_ids (`torch.LongTensor` dengan bentuk `(batch_size, 1)`, *opsional*, defaultnya `None`) : ID pembicara yang digunakan untuk mengondisikan fitur output ucapan oleh model.

lang_ids (`torch.LongTensor` dengan bentuk `(batch_size, 1)`, *opsional*, defaultnya `None`) : ID bahasa yang digunakan untuk mengondisikan fitur output ucapan oleh model.

speaker_embedding (`torch.Tensor` dengan bentuk `(batch_size, embedding_dim)`, *opsional*, default `None`) : Embedding yang berisi sinyal kondisioning untuk fitur dari ucapan.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

**Mengembalikan:** `FastSpeech2ConformerModelOutput` atau `tuple(torch.Tensor)`

A `FastSpeech2ConformerModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([FastSpeech2ConformerConfig](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)) dan input.

Metode forward dari [FastSpeech2ConformerWithHifiGan](/docs/transformers/main/id/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGan) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss untuk generasi spektrogram.
- **spectrogram** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, num_bins)`, *opsional*) -- Spektrogram yang diprediksi.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states dari encoder pada output setiap layer ditambah output embedding awal.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states dari decoder pada output setiap layer ditambah output embedding awal.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **duration_outputs** (`torch.LongTensor` dengan bentuk `(batch_size, max_text_length + 1)`, *opsional*) -- Output dari duration predictor.
- **pitch_outputs** (`torch.Tensor` dengan bentuk `(batch_size, max_text_length + 1, 1)`, *opsional*) -- Output dari prediktor pitch.
- **energy_outputs** (`torch.Tensor` dengan bentuk `(batch_size, max_text_length + 1, 1)`, *opsional*) -- Output dari prediktor energi.

Contoh:

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