# VITS

[VITS (Variational Inference with adversarial learning for end-to-end Text-to-Speech)](https://huggingface.co/papers/2106.06103) adalah model sintesis ucapan end-to-end yang menyederhanakan sistem text-to-speech (TTS) dua tahap tradisional. Keunikannya terletak pada kemampuannya mensintesis ucapan langsung dari teks menggunakan variational inference, adversarial learning, dan normalizing flows untuk menghasilkan ucapan yang natural dan ekspresif dengan ritme serta intonasi yang beragam.

Anda dapat menemukan semua checkpoint VITS asli di bawah organisasi [AI at Meta](https://huggingface.co/facebook?search_models=mms-tts).

> [!TIP]
> Klik model VITS di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan VITS.

Contoh di bawah ini menunjukkan cara menghasilkan teks berdasarkan gambar dengan [Pipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.Pipeline) atau kelas [AutoModel](/docs/transformers/main/id/model_doc/auto#transformers.AutoModel).

```python
from scipy.io.wavfile import write

from transformers import pipeline, set_seed

set_seed(555)

pipe = pipeline(
    task="text-to-speech",
    model="facebook/mms-tts-eng",
    device=0
)

speech = pipe("Hello, my dog is cute")

# Extract audio data and sampling rate
audio_data = speech["audio"]
sampling_rate = speech["sampling_rate"]

# Save as WAV file
write("hello.wav", sampling_rate, audio_data.squeeze())
```

```python
import scipy
import torch
from IPython.display import Audio

from transformers import AutoTokenizer, VitsModel, set_seed

tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng", device_map="auto")
inputs = tokenizer("Hello, my dog is cute", return_tensors="pt").to(model.device)

set_seed(555)

with torch.no_grad():
    outputs = model(**inputs)

waveform = outputs.waveform[0]
scipy.io.wavfile.write("hello.wav", rate=model.config.sampling_rate, data=waveform)

# display in Colab notebook
Audio(waveform, rate=model.config.sampling_rate)
```

## Catatan

- Atur seed untuk reproduktibilitas karena VITS mensintesis ucapan secara non-deterministik.
- Untuk bahasa dengan alfabet non-Romawi (Korea, Arab, dll.), instal paket [uroman](https://github.com/isi-nlp/uroman) untuk memproses pra-tekst input ke alfabet Romawi. Anda dapat memeriksa apakah tokenizer memerlukan uroman seperti yang ditunjukkan di bawah ini.

   ```py
   # pip install -U uroman
   from transformers import VitsTokenizer

   tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
   print(tokenizer.is_uroman)
   ```

   Jika bahasa Anda memerlukan uroman, tokenizer secara otomatis menerapkannya ke input teks.

## VitsConfig[[transformers.VitsConfig]]

#### transformers.VitsConfig[[transformers.VitsConfig]]

```python
transformers.VitsConfig(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, vocab_size: int = 38, hidden_size: int = 192, num_hidden_layers: int = 6, num_attention_heads: int = 2, window_size: int = 4, use_bias: bool = True, ffn_dim: int = 768, layerdrop: float | int = 0.1, ffn_kernel_size: int = 3, flow_size: int = 192, spectrogram_bins: int = 513, hidden_act: str = 'relu', hidden_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_stochastic_duration_prediction: bool = True, num_speakers: int = 1, speaker_embedding_size: int = 0, 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 = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), leaky_relu_slope: float = 0.1, depth_separable_channels: int = 2, depth_separable_num_layers: int = 3, duration_predictor_flow_bins: int = 10, duration_predictor_tail_bound: float = 5.0, duration_predictor_kernel_size: int = 3, duration_predictor_dropout: float | int = 0.5, duration_predictor_num_flows: int = 4, duration_predictor_filter_channels: int = 256, prior_encoder_num_flows: int = 4, prior_encoder_num_wavenet_layers: int = 4, posterior_encoder_num_wavenet_layers: int = 16, wavenet_kernel_size: int = 5, wavenet_dilation_rate: int = 1, wavenet_dropout: float | int = 0.0, speaking_rate: float | int = 1.0, noise_scale: float = 0.667, noise_scale_duration: float = 0.8, sampling_rate: int = 16000, pad_token_id: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/configuration_vits.py#L24)

**Parameter:**

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

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

num_hidden_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

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

window_size (`int`, *opsional*, default 4) : Ukuran jendela untuk embedding posisi relatif di lapisan perhatian dari encoder Transformer.

use_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan bias pada lapisan proyeksi key, query, dan value di encoder Transformer.

ffn_dim (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi MLP.

layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas LayerDrop. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut.

ffn_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel dari lapisan konvolusi 1D yang digunakan oleh jaringan feed-forward dalam encoder Transformer.

flow_size (`int`, *opsional*, default 192) : Dimensi dari lapisan flow.

spectrogram_bins (`int`, *opsional*, defaultnya 513) : Jumlah bin frekuensi dalam spektrogram target.

hidden_act (`str`, *opsional*, defaultnya `relu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

hidden_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian.

activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected.

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

layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

use_stochastic_duration_prediction (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan modul prediksi durasi stokastik atau prediktor durasi reguler.

num_speakers (`int`, *opsional*, default 1) : Jumlah pembicara jika ini adalah model multi-pembicara.

speaker_embedding_size (`int`, *opsional*, default 0) : Jumlah channel yang digunakan oleh speaker embeddings. Nilainya nol untuk model single-speaker.

upsample_initial_channel (`int`, *opsional*, default 512) : Jumlah saluran input ke jaringan upsampling HiFi-GAN.

upsample_rates (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[8, 8, 2, 2]`) : Tuple bilangan bulat yang mendefinisikan stride dari setiap lapisan konvolusional 1D dalam jaringan upsampling HiFi-GAN. 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 HiFi-GAN. 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) HiFi-GAN.

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

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

depth_separable_channels (`int`, *opsional*, defaultnya 2) : Jumlah channel yang digunakan di setiap blok depth-separable.

depth_separable_num_layers (`int`, *opsional*, defaultnya 3) : Jumlah lapisan konvolusional yang digunakan di setiap blok depth-separable.

duration_predictor_flow_bins (`int`, *opsional*, default 10) : Jumlah channel yang dipetakan menggunakan unonstrained rational spline dalam model duration predictor.

duration_predictor_tail_bound (`float`, *opsional*, defaultnya 5.0) : Nilai batas bin ekor saat menghitung spline rasional tak terbatas dalam model prediktor durasi.

duration_predictor_kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel dari lapisan konvolusi 1D yang digunakan dalam model duration predictor.

duration_predictor_dropout (`float`, *opsional*, default 0.5) : Rasio dropout untuk model prediktor durasi.

duration_predictor_num_flows (`int`, *opsional*, defaultnya 4) : Jumlah tahap aliran yang digunakan oleh model duration predictor.

duration_predictor_filter_channels (`int`, *opsional*, default 256) : Jumlah channel untuk lapisan konvolusi yang digunakan dalam model duration predictor.

prior_encoder_num_flows (`int`, *opsional*, default 4) : Jumlah tahap alur yang digunakan oleh model alur encoder prior.

prior_encoder_num_wavenet_layers (`int`, *opsional*, default 4) : Jumlah lapisan WaveNet yang digunakan oleh model alur encoder prior.

posterior_encoder_num_wavenet_layers (`int`, *opsional*, default 16) : Jumlah lapisan WaveNet yang digunakan oleh model posterior encoder.

wavenet_kernel_size (`int`, *opsional*, default 5) : Ukuran kernel dari lapisan konvolusi 1D yang digunakan dalam model WaveNet.

wavenet_dilation_rate (`int`, *opsional*, default 1) : Laju dilatasi dari lapisan konvolusi 1D yang berdilatasi yang digunakan dalam model WaveNet.

wavenet_dropout (`float`, *opsional*, default 0.0) : Rasio dropout untuk lapisan WaveNet.

speaking_rate (`float`, *opsional*, default 1.0) : Laju bicara. Nilai yang lebih besar menghasilkan suara sintesis yang lebih cepat.

noise_scale (`float`, *opsional*, default 0.667) : Seberapa acak prediksi ucapan. Nilai yang lebih besar menciptakan variasi lebih besar dalam ucapan yang diprediksi.

noise_scale_duration (`float`, *opsional*, default 0.8) : Seberapa acak prediksi durasi. Nilai yang lebih besar menciptakan variasi lebih besar dalam durasi yang diprediksi.

sampling_rate (`int`, *opsional*, defaultnya `16000`) : Laju sampling di mana file audio harus didigitalisasi, dinyatakan dalam hertz (Hz).

pad_token_id (`int`, *opsional*) : ID token yang digunakan untuk padding dalam kosakata.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VitsModel. Kelas ini digunakan untuk membuat instans model Vits sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/mms-tts-eng](https://huggingface.co/facebook/mms-tts-eng)

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 VitsModel, VitsConfig

>>> # Initializing a "facebook/mms-tts-eng" style configuration
>>> configuration = VitsConfig()

>>> # Initializing a model (with random weights) from the "facebook/mms-tts-eng" style configuration
>>> model = VitsModel(configuration)

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

## VitsTokenizer[[transformers.VitsTokenizer]]

#### transformers.VitsTokenizer[[transformers.VitsTokenizer]]

```python
transformers.VitsTokenizer(vocab_file, pad_token = '<pad>', unk_token = '<unk>', language = None, add_blank = True, normalize = True, phonemize = True, is_uroman = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/tokenization_vits.py#L46)

**Parameter:**

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

language (`str`, *opsional*) : Pengidentifikasi bahasa.

add_blank (`bool`, *opsional*, defaultnya `True`) : Apakah menyisipkan token id 0 di antara token lainnya.

normalize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi teks input dengan menghapus semua kapitalisasi dan tanda baca.

phonemize (`bool`, *opsional*, defaultnya `True`) : Apakah teks input akan dikonversi menjadi fonem.

is_uroman (`bool`, *opsional*, defaultnya `False`) : Apakah Romanizer `uroman` perlu diterapkan pada teks input sebelum tokenisasi.

Membangun tokenizer VITS. Mendukung juga MMS-TTS.

Tokenizer ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend) yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

#### __call__[[transformers.VitsTokenizer.__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.VitsTokenizer.save_vocabulary]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/tokenization_vits.py#L232)

## VitsModel[[transformers.VitsModel]]

#### transformers.VitsModel[[transformers.VitsModel]]

```python
transformers.VitsModel(config: VitsConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/modeling_vits.py#L1228)

**Parameter:**

config ([VitsConfig](/docs/transformers/main/id/model_doc/vits#transformers.VitsConfig)) : 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 VITS lengkap, untuk sintesis teks-ke-bicara.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, speaker_id: int | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, speaking_rate: float | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vits/modeling_vits.py#L1255)

**Parameter:**

input_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` 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)

speaker_id (`int`, *opsional*) : Embedding pembicara mana yang akan digunakan. Hanya digunakan untuk model multi-pembicara.

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.

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

labels (`torch.Tensor` dengan bentuk `(batch_size, config.spectrogram_bins, sequence_length)`, *opsional*) : Nilai float dari spektrogram target. Timestep yang diset ke `-100.0` diabaikan (diberi mask) untuk perhitungan loss.

speaking_rate (`float`, *opsional*) : Laju bicara.

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

Sebuah `VitsModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([VitsConfig](/docs/transformers/main/id/model_doc/vits#transformers.VitsConfig)) dan input.

Metode forward dari [VitsModel](/docs/transformers/main/id/model_doc/vits#transformers.VitsModel) 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.

- **waveform** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Gelombang audio akhir yang diprediksi oleh model.
- **sequence_lengths** (`torch.Tensor` dengan bentuk `(batch_size,)`) -- Panjang dalam sampel untuk setiap elemen dalam batch `waveform`.
- **spectrogram** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, num_bins)`) -- Spektragram log-mel yang diprediksi pada keluaran model flow. Spektragram ini diteruskan ke model decoder Hi-Fi GAN untuk mendapatkan gelombang audio final.
- **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 model pada output setiap layer ditambah output embedding awal yang opsional.
- **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 setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import VitsTokenizer, VitsModel, set_seed
>>> import torch

>>> tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
>>> model = VitsModel.from_pretrained("facebook/mms-tts-eng")

>>> inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

>>> set_seed(555)  # make deterministic

>>> with torch.no_grad():
...     outputs = model(inputs["input_ids"])
>>> outputs.waveform.shape
torch.Size([1, 45824])
```