# UnivNet

## Ikhtisar

Model UnivNet diusulkan dalam [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) oleh Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin, dan Juntae Kim. Model UnivNet adalah generative adversarial network (GAN) yang dilatih untuk mensintesis waveform ucapan berkefideltasan tinggi. Model UnivNet yang dibagikan di `transformers` adalah *generator*, yang memetakan log-mel spectrogram kondisional dan urutan noise opsional ke waveform ucapan (misalnya, vocoder). Hanya generator yang diperlukan untuk inferensi. *discriminator* yang digunakan untuk melatih `generator` tidak diimplementasikan.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Sebagian besar voder neural menggunakan mel-spectrogram berbatas pita untuk menghasilkan waveform. Jika fitur spektral pita penuh digunakan sebagai input, voder dapat diberikan informasi akustik sebanyak mungkin. Namun, pada beberapa model yang menggunakan mel-spectrogram pita penuh, terjadi masalah over-smoothing, di mana dihasilkan spectrogram yang tidak tajam. Untuk mengatasi masalah ini, kami mengusulkan UnivNet, sebuah voder neural yang mensintesis waveform berkeandalan tinggi secara real time. Terinspirasi oleh karya-karya di bidang deteksi aktivitas suara, kami menambahkan diskriminator spectrogram multi-resolusi yang menggunakan beberapa magnitudo spectrogram linear yang dihitung menggunakan berbagai set parameter. Dengan menggunakan mel-spectrogram pita penuh sebagai input, kami berharap dapat menghasilkan sinyal beresolusi tinggi dengan menambahkan diskriminator yang menggunakan spectrogram multi-resolusi sebagai input. Dalam evaluasi pada dataset yang berisi informasi tentang ratusan pembicara, UnivNet memperoleh hasil objektif dan subjektif terbaik di antara model-model pesaing, baik untuk pembicara yang sudah dikenal maupun yang belum dikenal. Hasil-hasil ini, termasuk skor subjektif terbaik untuk text-to-speech, menunjukkan potensi adaptasi cepat ke pembicara baru tanpa perlu pelatihan dari awal.*

Tips:

- Argumen `noise_sequence` untuk [UnivNetModel.forward()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetModel.forward) harus berupa noise Gaussian standar (misalnya dari `torch.randn`) dengan bentuk `([batch_size], noise_length, model.config.model_in_channels)`, di mana `noise_length` harus sesuai dengan dimensi panjang (dimensi 1) dari argumen `input_features`. Jika tidak diberikan, noise akan dihasilkan secara acak; sebuah `torch.Generator` dapat diberikan ke argumen `generator` agar forward pass dapat direproduksi. (Perhatikan bahwa [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor) akan mengembalikan noise yang dihasilkan secara default, sehingga seharusnya tidak perlu menghasilkan `noise_sequence` secara manual.)
- Padding yang ditambahkan oleh [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor) dapat dihapus dari output [UnivNetModel](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetModel) melalui metode `UnivNetFeatureExtractor.batch_decode()`, seperti yang ditunjukkan pada contoh penggunaan di bawah ini.
- Menambahkan padding berupa keheningan di akhir setiap waveform dapat mengurangi artefak di bagian akhir sampel audio yang dihasilkan. Hal ini dapat dilakukan dengan memberikan `pad_end = True` ke [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Lihat [isu ini](https://github.com/seungwonpark/melgan/issues/8) untuk detail lebih lanjut.

Contoh Penggunaan:

```python
import torch
from datasets import Audio, load_dataset
from scipy.io.wavfile import write

from transformers import UnivNetFeatureExtractor, UnivNetModel

model_id_or_path = "dg845/univnet-dev"
model = UnivNetModel.from_pretrained(model_id_or_path, device_map="auto")
feature_extractor = UnivNetFeatureExtractor.from_pretrained(model_id_or_path)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
# Resample the audio to the model and feature extractor's sampling rate.
ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
# Pad the end of the converted waveforms to reduce artifacts at the end of the output audio samples.
inputs = feature_extractor(
    ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], pad_end=True, return_tensors="pt"
)

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

# Remove the extra padding at the end of the output.
audio = feature_extractor.batch_decode(**audio)[0]
# Convert to wav file
write("sample_audio.wav", feature_extractor.sampling_rate, audio)
```

Model ini disumbangkan oleh [dg845](https://huggingface.co/dg845). Sejauh pengetahuan saya, tidak ada rilis kode resmi, tetapi implementasi tidak resmi dapat ditemukan di [maum-ai/univnet](https://github.com/maum-ai/univnet) dengan checkpoint terlatih [di sini](https://github.com/maum-ai/univnet#pre-trained-model).

## UnivNetConfig[[transformers.UnivNetConfig]]

#### transformers.UnivNetConfig[[transformers.UnivNetConfig]]

```python
transformers.UnivNetConfig(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_channels: int = 64, model_hidden_channels: int = 32, num_mel_bins: int = 100, resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 3), resblock_stride_sizes: list[int] | tuple[int, ...] = (8, 8, 4), resblock_dilation_sizes: list | tuple = ((1, 3, 9, 27), (1, 3, 9, 27), (1, 3, 9, 27)), kernel_predictor_num_blocks: int = 3, kernel_predictor_hidden_channels: int = 64, kernel_predictor_conv_size: int = 3, kernel_predictor_dropout: float | int = 0.0, initializer_range: float = 0.01, leaky_relu_slope: float = 0.2)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/configuration_univnet.py#L24)

**Parameter:**

model_in_channels (`int`, *opsional*, defaultnya 64) : Jumlah saluran input untuk jaringan residual UnivNet. Nilai ini harus sesuai dengan `noise_sequence.shape[1]` dan nilai yang digunakan dalam kelas [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor).

model_hidden_channels (`int`, *opsional*, defaultnya 32) : Jumlah kanal tersembunyi dari setiap blok residual dalam jaringan residual UnivNet.

num_mel_bins (`int`, *opsional*, default 100) : Jumlah bin frekuensi dalam spektrogram log-mel kondisional. Nilai ini harus sesuai dengan nilai yang digunakan dalam kelas [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor).

resblock_kernel_sizes (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[3, 3, 3]`) : Tuple bilangan bulat yang mendefinisikan ukuran kernel dari lapisan konvolusional 1D dalam jaringan residual UnivNet. Panjang dari `resblock_kernel_sizes` mendefinisikan jumlah blok resnet dan harus sesuai dengan `resblock_stride_sizes` dan `resblock_dilation_sizes`.

resblock_stride_sizes (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `[8, 8, 4]`) : Tuple bilangan bulat yang mendefinisikan ukuran stride dari lapisan konvolusional 1D dalam jaringan residual UnivNet. Panjang `resblock_stride_sizes` harus sama dengan panjang `resblock_kernel_sizes` dan `resblock_dilation_sizes`.

resblock_dilation_sizes (`tuple[tuple[int]]` atau `list[list[int]]`, *opsional*, defaultnya `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : Tuple bersarang dari bilangan bulat yang mendefinisikan laju dilatasi dari lapisan konvolusi 1D yang di-dilasi dalam jaringan residual UnivNet. Panjang `resblock_dilation_sizes` harus sesuai dengan panjang `resblock_kernel_sizes` dan `resblock_stride_sizes`. Panjang setiap daftar bersarang dalam `resblock_dilation_sizes` mendefinisikan jumlah lapisan konvolusi per blok resnet.

kernel_predictor_num_blocks (`int`, *opsional*, defaultnya 3) : Jumlah blok residual dalam jaringan prediktor kernel, yang menghitung kernel dan bias untuk setiap lapisan konvolusi variabel lokasi dalam jaringan residual UnivNet.

kernel_predictor_hidden_channels (`int`, *opsional*, defaultnya 64) : Jumlah kanal tersembunyi untuk setiap blok residual dalam jaringan prediktor kernel.

kernel_predictor_conv_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel dari setiap lapisan konvolusional 1D dalam jaringan prediktor kernel.

kernel_predictor_dropout (`float`, *opsional*, default 0.0) : Probabilitas dropout untuk setiap blok residual dalam jaringan prediktor kernel.

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.2) : Sudut kemiringan negatif yang digunakan oleh aktivasi leaky ReLU.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari UnivNetModel. Kelas ini digunakan untuk membuat instans model Univnet sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev)

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

Contoh:

```python
>>> from transformers import UnivNetModel, UnivNetConfig

>>> # Initializing a Tortoise TTS style configuration
>>> configuration = UnivNetConfig()

>>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
>>> model = UnivNetModel(configuration)

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

## UnivNetFeatureExtractor[[transformers.UnivNetFeatureExtractor]]

#### transformers.UnivNetFeatureExtractor[[transformers.UnivNetFeatureExtractor]]

```python
transformers.UnivNetFeatureExtractor(feature_size: int = 1, sampling_rate: int = 24000, padding_value: float = 0.0, do_normalize: bool = False, num_mel_bins: int = 100, hop_length: int = 256, win_length: int = 1024, win_function: str = 'hann_window', filter_length: int | None = 1024, max_length_s: int = 10, fmin: float = 0.0, fmax: float | None = None, mel_floor: float = 1e-09, center: bool = False, compression_factor: float = 1.0, compression_clip_val: float = 1e-05, normalize_min: float = -11.512925148010254, normalize_max: float = 2.3143386840820312, model_in_channels: int = 64, pad_end_length: int = 10, return_attention_mask = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/feature_extraction_univnet.py#L29)

**Parameter:**

feature_size (`int`, *opsional*, default 1) : Dimensi fitur dari fitur yang diekstrak.

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

padding_value (`float`, *opsional*, default 0.0) : Nilai yang digunakan untuk mengisi saat menerapkan strategi `padding` yang didefinisikan oleh argumen `padding` pada [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Seharusnya sesuai dengan keheningan audio. Argumen `pad_end` pada `__call__` juga akan menggunakan nilai pengisi ini.

do_normalize (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan normalisasi Tacotron 2 pada input. Normalisasi dapat membantu meningkatkan kinerja secara signifikan untuk beberapa model.

num_mel_bins (`int`, *opsional*, default 100) : Jumlah bin frekuensi mel dalam fitur spektrogram yang diekstrak. Nilai ini harus sesuai dengan `UnivNetModel.config.num_mel_bins`.

hop_length (`int`, *opsional*, default 256) : Jumlah sampel langsung di antara jendela geser. Istilah lain yang sering digunakan dalam banyak paper adalah "shift". Perhatikan bahwa ini berbeda dari ekstraktor fitur audio lainnya seperti [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) yang mengambil `hop_length` dalam ms.

win_length (`int`, *opsional*, default 1024) : Jumlah sampel langsung untuk setiap sliding window. Perhatikan bahwa ini berbeda dari audio feature extractor lainnya seperti [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) yang mengambil `win_length` dalam ms.

win_function (`str`, *opsional*, defaultnya `"hann_window"`) : Nama untuk fungsi window yang digunakan untuk windowing, harus dapat diakses melalui `torch.{win_function}`

filter_length (`int`, *opsional*, default 1024) : Jumlah komponen FFT yang akan digunakan. Jika `None`, nilai ini ditentukan menggunakan `transformers.audio_utils.optimal_fft_length`.

max_length_s (`int`, *opsional*, default 10) : Panjang maksimum input model dalam detik. Ini digunakan untuk melakukan padding pada audio.

fmin (`float`, *opsional*, default 0.0) : Frekuensi mel minimum dalam Hz.

fmax (`float`, *opsional*) : Frekuensi mel maksimum dalam Hz. Jika tidak diatur, defaultnya adalah `sampling_rate / 2`.

mel_floor (`float`, *opsional*, default 1e-09) : Nilai minimum dari bank frekuensi mel. Perhatikan bahwa cara [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor) menggunakan `mel_floor` berbeda dengan di [transformers.audio_utils.spectrogram()](/docs/transformers/v5.23.0/id/internal/audio_utils#transformers.audio_utils.spectrogram).

center (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan padding pada waveform sehingga frame `t` terpusat di sekitar waktu `t * hop_length`. Jika `False`, frame `t` akan dimulai pada waktu `t * hop_length`.

compression_factor (`float`, *opsional*, default 1.0) : Faktor kompresi multiplikatif untuk kompresi rentang dinamis selama normalisasi spektral.

compression_clip_val (`float`, *opsional*, default 1e-05) : Nilai clip yang diterapkan pada waveform sebelum menerapkan kompresi rentang dinamis selama normalisasi spektral.

normalize_min (`float`, *opsional*, defaultnya -11.512925148010254) : Nilai minimum yang digunakan untuk normalisasi linear bergaya Tacotron 2. Defaultnya adalah nilai asli dari implementasi Tacotron 2.

normalize_max (`float`, *opsional*, defaultnya 2.3143386840820312) : Nilai maksimum yang digunakan untuk normalisasi linear bergaya Tacotron 2. Defaultnya adalah nilai asli dari implementasi Tacotron 2.

model_in_channels (`int`, *opsional*, default 64) : Jumlah saluran input ke model [UnivNetModel](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetModel). Nilai ini harus sesuai dengan `UnivNetModel.config.model_in_channels`.

pad_end_length (`int`, *opsional*, default 10) : Jika melakukan padding di akhir setiap waveform, jumlah frame spectrogram yang setara dengan sampel untuk ditambahkan. Jumlah sampel yang ditambahkan akan menjadi `pad_end_length * hop_length`.

return_attention_mask (`bool`, *opsional*, defaultnya `True`) : Apakah [__call__()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) harus mengembalikan `attention_mask` atau tidak.

Membangun feature extractor UnivNet.

Kelas ini mengekstrak fitur log-mel-filter bank dari ucapan mentah menggunakan short time Fourier Transform (STFT). Implementasi STFT mengikuti TacoTron 2 dan Hifi-GAN.

Feature extractor ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

#### __call__[[transformers.UnivNetFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_noise: bool = True, generator: numpy.random._generator.Generator | None = None, pad_end: bool = False, pad_length: int | None = None, do_normalize: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/feature_extraction_univnet.py#L286)

**Parameter:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Urutan atau batch dari urutan-urutan yang akan di-pad. Setiap urutan dapat berupa array numpy, daftar nilai float, daftar array numpy, atau daftar dari daftar nilai float. Harus berupa audio mono channel, bukan stereo, yaitu satu float per timestep.

sampling_rate (`int`, *opsional*) : Laju pengambilan sampel di mana input `raw_speech` diambil. Sangat disarankan untuk meneruskan `sampling_rate` pada panggilan forward untuk mencegah kesalahan yang tidak terdeteksi dan memungkinkan pipeline pengenalan ucapan otomatis.

padding (`bool`, `str` or [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, defaults to `True`) : Select a strategy to pad the input `raw_speech` waveforms (according to the model's padding side and padding index) among:  - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence if provided). - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum acceptable input length for the model if that argument is not provided. - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different lengths).  If `pad_end = True`, that padding will occur before the `padding` strategy is applied.

max_length (`int`, *opsional*) : Panjang maksimum dari daftar yang dikembalikan dan secara opsional panjang padding (lihat di atas).

truncation (`bool`, *opsional*, defaultnya `True`) : Mengaktifkan pemotongan untuk memotong urutan input yang lebih panjang dari `max_length` menjadi `max_length`.

pad_to_multiple_of (`int`, *opsional*) : Jika diset, akan melakukan padding pada urutan menjadi kelipatan dari nilai yang diberikan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta), atau pada TPU yang diuntungkan dari panjang urutan yang merupakan kelipatan 128.

return_noise (`bool`, *opsional*, defaultnya `True`) : Apakah akan menghasilkan dan mengembalikan gelombang noise untuk digunakan dalam [UnivNetModel.forward()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetModel.forward).

generator (`numpy.random.Generator`, *opsional*, defaultnya `None`) : Generator angka acak `numpy.random.Generator` opsional yang akan digunakan saat menghasilkan noise.

pad_end (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan padding berupa keheningan di akhir setiap waveform. Hal ini dapat membantu mengurangi artefak di akhir sampel audio yang dihasilkan; lihat https://github.com/seungwonpark/melgan/issues/8 untuk detail lebih lanjut. Padding ini akan dilakukan sebelum strategi padding yang ditentukan dalam `padding` dijalankan.

pad_length (`int`, *opsional*, defaultnya `None`) : Jika melakukan padding di akhir setiap waveform, panjang padding dalam frame spektrogram. Jika tidak diatur, ini akan default ke `self.config.pad_end_length`.

do_normalize (`bool`, *opsional*) : Apakah akan melakukan normalisasi Tacotron 2 pada input. Normalisasi dapat membantu meningkatkan kinerja secara signifikan untuk beberapa model. Jika tidak diatur, ini akan secara default menjadi `self.config.do_normalize`.

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, attention mask akan dikembalikan sesuai dengan default dari feature_extractor tertentu.  [Apa itu attention mask?](../glossary#attention-mask)

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

Metode utama untuk melakukan featurisasi dan persiapan satu atau beberapa sekuens untuk model.

## UnivNetModel[[transformers.UnivNetModel]]

#### transformers.UnivNetModel[[transformers.UnivNetModel]]

```python
transformers.UnivNetModel(config: UnivNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/modeling_univnet.py#L425)

**Parameter:**

config ([UnivNetConfig](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Univnet polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.UnivNetModel.forward]]

```python
forward(input_features: Tensor, noise_sequence: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/modeling_univnet.py#L469)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor). Lihat [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) untuk detailnya (`processor_class` menggunakan [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetFeatureExtractor) untuk memproses audio).

noise_sequence (`torch.Tensor`, *opsional*) : Tensor yang berisi sekuens noise dari noise Gaussian standar. Dapat di-batch dengan bentuk `(batch_size, sequence_length, config.model_in_channels)`, atau tanpa batch dengan bentuk (sequence_length, config.model_in_channels)`. Jika tidak diberikan, akan dihasilkan secara acak.

padding_mask (`torch.BoolTensor`, *opsional*) : Mask yang menunjukkan bagian mana dari setiap urutan yang di-pad. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask** - 0 untuk token yang **di-mask**  Mask dapat di-batch dengan bentuk `(batch_size, sequence_length)` atau tanpa batch dengan bentuk `(sequence_length,)`.

generator (`torch.Generator`, *opsional*) : Sebuah [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat generasi menjadi deterministik. return_dict: Apakah akan mengembalikan subclass [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

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

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

`UnivNetModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([UnivNetConfig](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetConfig)) dan input.

Metode forward dari [UnivNetModel](/docs/transformers/v5.23.0/id/model_doc/univnet#transformers.UnivNetModel) 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.

- **gelombang suara** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Gelombang suara audio keluaran 1D (mono-channel) yang di-batch.
- **waveform_lengths** (`torch.Tensor` dengan bentuk `(batch_size,)`) -- Panjang batch dalam sampel untuk setiap waveform tanpa padding di `waveforms`.

Contoh:

```python
>>> from transformers import UnivNetFeatureExtractor, UnivNetModel
>>> from datasets import load_dataset, Audio

>>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
>>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> # Resample the audio to the feature extractor's sampling rate.
>>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> audio = model(**inputs).waveforms
>>> list(audio.shape)
[1, 140288]
```

