# UnivNet

## Tổng quan

Mô hình UnivNet được đề xuất trong [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) bởi Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin và Juntae Kim. Mô hình UnivNet là một mạng đối kháng sinh (GAN) được huấn luyện để tổng hợp các dạng sóng âm thanh có độ trung thực cao. Mô hình UnivNet được chia sẻ trong `transformers` là *generator*, có chức năng ánh xạ một phổ log-mel điều kiện và một chuỗi nhiễu tùy chọn thành dạng sóng âm thanh (ví dụ: một vocoder). Chỉ cần generator để suy luận. *discriminator* được sử dụng để huấn luyện `generator` không được triển khai.

Tóm tắt từ bài báo như sau:

*Phần lớn các bộ mã hóa giọng nói (vocoder) dựa trên mạng nơ-ron sử dụng mel-spectrogram giới hạn băng tần để tạo ra dạng sóng. Nếu các đặc trưng phổ toàn băng được dùng làm đầu vào, bộ mã hóa giọng nói có thể nhận được càng nhiều thông tin âm học càng tốt. Tuy nhiên, ở một số mô hình sử dụng mel-spectrogram toàn băng, vấn đề làm mịn quá mức xảy ra, dẫn đến việc tạo ra các spectrogram không sắc nét. Để giải quyết vấn đề này, chúng tôi đề xuất UnivNet, một bộ mã hóa giọng nói dựa trên mạng nơ-ron có khả năng tổng hợp dạng sóng độ trung thực cao theo thời gian thực. Lấy cảm hứng từ các công trình trong lĩnh vực phát hiện hoạt động giọng nói, chúng tôi đã thêm vào một bộ phân biệt (discriminator) spectrogram đa phân giải, sử dụng nhiều độ lớn của spectrogram tuyến tính được tính toán bằng các bộ tham số khác nhau. Bằng cách sử dụng mel-spectrogram toàn băng làm đầu vào, chúng tôi kỳ vọng sẽ tạo ra các tín hiệu độ phân giải cao nhờ việc thêm một bộ phân biệt sử dụng các spectrogram ở nhiều mức độ phân giải khác nhau làm đầu vào. Trong một đánh giá trên bộ dữ liệu chứa thông tin về hàng trăm người nói, UnivNet đạt được kết quả khách quan và chủ quan tốt nhất trong số các mô hình cạnh tranh, cho cả người nói đã biết lẫn chưa biết. Những kết quả này, bao gồm điểm chủ quan tốt nhất cho hệ thống chuyển văn bản thành giọng nói, cho thấy tiềm năng thích ứng nhanh với người nói mới mà không cần huấn luyện lại từ đầu.*

Mẹo:

- Tham số `noise_sequence` của [UnivNetModel.forward()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetModel.forward) phải là nhiễu Gaussian chuẩn (ví dụ từ `torch.randn`) có hình dạng `([batch_size], noise_length, model.config.model_in_channels)`, trong đó `noise_length` phải khớp với chiều dài (chiều 1) của tham số `input_features`. Nếu không được cung cấp, nó sẽ được tạo ngẫu nhiên; một `torch.Generator` có thể được cung cấp cho tham số `generator` để quá trình truyền tiến có thể được tái tạo. (Lưu ý rằng [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor) sẽ trả về nhiễu đã tạo theo mặc định, vì vậy không cần thiết phải tạo `noise_sequence` thủ công.)
- Phần padding được thêm bởi [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor) có thể được loại bỏ khỏi đầu ra của [UnivNetModel](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetModel) thông qua phương thức `UnivNetFeatureExtractor.batch_decode()`, như minh họa trong ví dụ sử dụng bên dưới.
- Việc đệm phần cuối của mỗi waveform bằng im lặng có thể giảm thiểu các hiện tượng méo ở cuối mẫu âm thanh được tạo ra. Bạn có thể thực hiện điều này bằng cách cung cấp `pad_end = True` cho [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Xem [vấn đề này](https://github.com/seungwonpark/melgan/issues/8) để biết thêm chi tiết.

Ví dụ sử dụng:

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

Mô hình này được đóng góp bởi [dg845](https://huggingface.co/dg845). Theo hiểu biết của tôi, không có bản phát hành mã chính thức nào, nhưng có thể tìm thấy một bản triển khai không chính thức tại [maum-ai/univnet](https://github.com/maum-ai/univnet) với các checkpoint được huấn luyện trước [tại đây](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)
```

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

**Tham số:**

model_in_channels (`int`, *optional*, mặc định là 64) : Số lượng kênh đầu vào cho mạng residual UnivNet. Giá trị này phải tương ứng với `noise_sequence.shape[1]` và giá trị được sử dụng trong lớp [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor).

model_hidden_channels (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng kênh ẩn của mỗi khối dư trong mạng dư UnivNet.

num_mel_bins (`int`, *tuỳ chọn*, mặc định là 100) : Số lượng bin tần số trong phổ log-mel điều kiện. Giá trị này phải tương ứng với giá trị được sử dụng trong lớp [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor).

resblock_kernel_sizes (`tuple[int]` hoặc `list[int]`, *tuỳ chọn*, mặc định là `[3, 3, 3]`) : Một tuple các số nguyên xác định kích thước kernel của các lớp tích chập 1D trong mạng residual UnivNet. Độ dài của `resblock_kernel_sizes` xác định số lượng khối resnet và phải khớp với độ dài của `resblock_stride_sizes` và `resblock_dilation_sizes`.

resblock_stride_sizes (`tuple[int]` hoặc `list[int]`, *tuỳ chọn*, mặc định là `[8, 8, 4]`) : Một tuple các số nguyên xác định kích thước bước (stride) của các lớp tích chập 1D trong mạng residual của UnivNet. Độ dài của `resblock_stride_sizes` phải khớp với độ dài của `resblock_kernel_sizes` và `resblock_dilation_sizes`.

resblock_dilation_sizes (`tuple[tuple[int]]` hoặc `list[list[int]]`, *tùy chọn*, mặc định là `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : Một tuple lồng nhau của các số nguyên xác định các tỷ lệ giãn nở của các lớp tích chập 1D giãn nở trong mạng residual của UnivNet. Độ dài của `resblock_dilation_sizes` phải khớp với độ dài của `resblock_kernel_sizes` và `resblock_stride_sizes`. Độ dài của mỗi danh sách lồng nhau trong `resblock_dilation_sizes` xác định số lượng lớp tích chập cho mỗi khối resnet.

kernel_predictor_num_blocks (`int`, *tuỳ chọn*, mặc định là 3) : Số lượng khối dư (residual blocks) trong mạng dự đoán kernel, mạng này tính toán kernel và bias cho từng lớp biến đổi tích chập (convolution layer) của biến vị trí trong mạng dư UnivNet.

kernel_predictor_hidden_channels (`int`, *tuỳ chọn*, mặc định là 64) : Số lượng kênh ẩn cho mỗi khối dư trong mạng dự đoán kernel.

kernel_predictor_conv_size (`int`, *tuỳ chọn*, mặc định là 3) : Kích thước kernel của mỗi lớp tích chập 1D trong mạng dự đoán kernel.

kernel_predictor_dropout (`float`, *optional*, mặc định là 0.0) : Xác suất dropout cho mỗi khối residual trong mạng dự đoán kernel.

initializer_range (`float`, *optional*, mặc định là `0.01`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

leaky_relu_slope (`float`, *optional*, mặc định là 0.2) : Góc của độ dốc âm được sử dụng bởi hàm kích hoạt leaky ReLU.

Đây là lớp cấu hình để lưu trữ cấu hình của một UnivNetModel. Nó được sử dụng để khởi tạo một mô hình Univnet theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

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

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

**Tham số:**

feature_size (`int`, *tuỳ chọn*, mặc định là 1) : Kích thước chiều của các đặc trưng đã trích xuất.

sampling_rate (`int`, *optional*, mặc định là 24000) : Tốc độ lấy mẫu (sampling rate) mà các tệp âm thanh nên được số hóa, được biểu diễn bằng hertz (Hz).

padding_value (`float`, *optional*, mặc định là 0.0) : Giá trị dùng để đệm khi áp dụng chiến lược đệm được định nghĩa bởi đối số `padding` của [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Giá trị này nên tương ứng với sự im lặng của âm thanh. Đối số `pad_end` của `__call__` cũng sẽ sử dụng giá trị đệm này.

do_normalize (`bool`, *tùy chọn*, mặc định là `False`) : Có thực hiện chuẩn hóa Tacotron 2 trên đầu vào hay không. Việc chuẩn hóa có thể giúp cải thiện đáng kể hiệu suất cho một số mô hình.

num_mel_bins (`int`, *optional*, mặc định là 100) : Số lượng bin tần số mel trong các đặc trưng phổ được trích xuất. Giá trị này phải khớp với `UnivNetModel.config.num_mel_bins`.

hop_length (`int`, *optional*, mặc định là 256) : Số mẫu trực tiếp giữa các cửa sổ trượt. Còn được gọi là "shift" trong nhiều bài báo. Lưu ý rằng điều này khác với các bộ trích xuất đặc trưng âm thanh khác như [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), vốn nhận `hop_length` tính bằng ms.

win_length (`int`, *optional*, mặc định là 1024) : Số lượng mẫu trực tiếp cho mỗi cửa sổ trượt. Lưu ý rằng điều này khác với các bộ trích xuất đặc trưng âm thanh khác như [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), vốn nhận `win_length` tính bằng ms.

win_function (`str`, *tùy chọn*, mặc định là `"hann_window"`) : Tên của hàm cửa sổ được sử dụng cho việc tạo cửa sổ, phải có thể truy cập thông qua `torch.{win_function}`

filter_length (`int`, *tuỳ chọn*, mặc định là 1024) : Số lượng thành phần FFT cần sử dụng. Nếu là `None`, giá trị này sẽ được xác định bằng `transformers.audio_utils.optimal_fft_length`.

max_length_s (`int`, *optional*, mặc định là 10) : Độ dài tối đa của đầu vào mô hình tính bằng giây. Giá trị này được dùng để đệm (padding) âm thanh.

fmin (`float`, *tuỳ chọn*, mặc định là 0.0) : Tần số mel tối thiểu, tính bằng Hz.

fmax (`float`, *tuỳ chọn*) : Tần số mel tối đa, tính bằng Hz. Nếu không được đặt, giá trị mặc định là `sampling_rate / 2`.

mel_floor (`float`, *optional*, mặc định là 1e-09) : Giá trị tối thiểu của các ngân tần số mel. Lưu ý rằng cách [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor) sử dụng `mel_floor` khác với trong [transformers.audio_utils.spectrogram()](/docs/transformers/v5.23.0/vi/internal/audio_utils#transformers.audio_utils.spectrogram).

center (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đệm (pad) waveform để khung `t` được căn giữa quanh thời điểm `t * hop_length` hay không. Nếu `False`, khung `t` sẽ bắt đầu tại thời điểm `t * hop_length`.

compression_factor (`float`, *optional*, mặc định là 1.0) : Hệ số nén nhân cho việc nén dải động trong quá trình chuẩn hóa phổ.

compression_clip_val (`float`, *optional*, mặc định là 1e-05) : Giá trị clip được áp dụng cho waveform trước khi áp dụng nén dải động trong quá trình chuẩn hóa phổ.

normalize_min (`float`, *optional*, mặc định là -11.512925148010254) : Giá trị tối thiểu được sử dụng cho chuẩn hóa tuyến tính kiểu Tacotron 2. Giá trị mặc định là giá trị gốc từ triển khai Tacotron 2.

normalize_max (`float`, *optional*, mặc định là 2.3143386840820312) : Giá trị tối đa được sử dụng cho chuẩn hóa tuyến tính kiểu Tacotron 2. Giá trị mặc định là giá trị gốc từ triển khai Tacotron 2.

model_in_channels (`int`, *tuỳ chọn*, mặc định là 64) : Số lượng kênh đầu vào của mô hình [UnivNetModel](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetModel). Giá trị này phải khớp với `UnivNetModel.config.model_in_channels`.

pad_end_length (`int`, *optional*, mặc định là 10) : Nếu đệm cuối mỗi waveform, số mẫu tương đương với số khung spectrogram cần thêm vào. Số mẫu được thêm sẽ là `pad_end_length * hop_length`.

return_attention_mask (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem [__call__()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) có nên trả về `attention_mask` hay không.

Tạo bộ trích xuất đặc trưng UnivNet.

Lớp này trích xuất các đặc trưng log-mel-filter bank từ giọng nói thô bằng cách sử dụng Biến đổi Fourier thời gian ngắn (STFT). Việc triển khai STFT tuân theo TacoTron 2 và Hifi-GAN.

Feature extractor này kế thừa từ [SequenceFeatureExtractor](/docs/transformers/v5.23.0/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), bao gồm hầu hết các phương thức chính. Người dùng nên tham khảo lớp cha này để biết thêm thông tin về các phương thức đó.

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

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

**Tham số:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Chuỗi hoặc lô các chuỗi cần được đệm. Mỗi chuỗi có thể là một mảng numpy, một danh sách các giá trị float, một danh sách các mảng numpy hoặc một danh sách các danh sách giá trị float. Phải là âm thanh đơn kênh, không phải stereo, tức là một float duy nhất cho mỗi bước thời gian.

sampling_rate (`int`, *optional*) : Tốc độ lấy mẫu mà đầu vào `raw_speech` được lấy mẫu. Rất khuyến nghị truyền `sampling_rate` tại cuộc gọi forward để ngăn các lỗi âm thầm và cho phép pipeline nhận dạng giọng nói tự động.

padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, mặc định là `True`) : Chọn một chiến lược để đệm các dạng sóng `raw_speech` đầu vào (theo phía đệm và chỉ số đệm của mô hình) trong số các lựa chọn sau:  - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong batch (hoặc không đệm nếu chỉ có một chuỗi duy nhất được cung cấp). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một batch với các chuỗi có độ dài khác nhau).  Nếu `pad_end = True`, phần đệm đó sẽ được thực hiện trước khi chiến lược `padding` được áp dụng.

max_length (`int`, *optional*) : Độ dài tối đa của danh sách được trả về và tùy chọn độ dài padding (xem bên trên).

truncation (`bool`, *tùy chọn*, mặc định là `True`) : Kích hoạt việc cắt ngắn để giảm các chuỗi đầu vào dài hơn `max_length` xuống còn `max_length`.

pad_to_multiple_of (`int`, *optional*) : Nếu được đặt, sẽ đệm chuỗi đến một bội số của giá trị được cung cấp. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta), hoặc trên TPU, nơi mà việc có độ dài chuỗi là bội số của 128 sẽ mang lại lợi ích.

return_noise (`bool`, *tuỳ chọn*, mặc định là `True`) : Có tạo và trả về một dạng sóng nhiễu để sử dụng trong [UnivNetModel.forward()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetModel.forward) hay không.

generator (`numpy.random.Generator`, *tùy chọn*, mặc định là `None`) : Bộ tạo số ngẫu nhiên `numpy.random.Generator` tùy chọn để sử dụng khi tạo nhiễu.

pad_end (`bool`, *tuỳ chọn*, mặc định là `False`) : Có nên đệm im lặng vào cuối mỗi waveform hay không. Điều này có thể giúp giảm các hiện tượng méo ở cuối mẫu âm thanh được tạo ra; xem https://github.com/seungwonpark/melgan/issues/8 để biết thêm chi tiết. Việc đệm này sẽ được thực hiện trước khi áp dụng chiến lược đệm được chỉ định trong `padding`.

pad_length (`int`, *tuỳ chọn*, mặc định là `None`) : Nếu đệm cuối mỗi waveform, đây là độ dài của phần đệm tính bằng số khung spectrogram. Nếu không được đặt, giá trị này sẽ mặc định là `self.config.pad_end_length`.

do_normalize (`bool`, *tùy chọn*) : Có thực hiện chuẩn hóa Tacotron 2 trên đầu vào hay không. Việc chuẩn hóa có thể giúp cải thiện đáng kể hiệu suất cho một số mô hình. Nếu không được đặt, giá trị mặc định sẽ là `self.config.do_normalize`.

return_attention_mask (`bool`, *tùy chọn*) : Có trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của feature_extractor cụ thể.  [Attention mask là gì?](../glossary#attention-mask)

return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.np.array` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của Numpy.

Phương thức chính để tạo đặc trưng và chuẩn bị một hoặc nhiều chuỗi cho mô hình.

## UnivNetModel[[transformers.UnivNetModel]]

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

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

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

**Tham số:**

config ([UnivNetConfig](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Univnet cơ bản, xuất ra các hidden-states thô mà không có head cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor). Xem [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) để biết chi tiết (`processor_class` sử dụng [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetFeatureExtractor) để xử lý âm thanh).

noise_sequence (`torch.Tensor`, *optional*) : Tensor chứa một chuỗi nhiễu của nhiễu Gaussian chuẩn. Có thể được batch và có shape `(batch_size, sequence_length, config.model_in_channels)`, hoặc không batch và có shape (sequence_length, config.model_in_channels)`. Nếu không được cung cấp, sẽ được tạo ngẫu nhiên.

padding_mask (`torch.BoolTensor`, *tùy chọn*) : Mặt nạ chỉ ra các phần nào của mỗi chuỗi bị đệm. Giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che** - 0 cho các token **bị che**  Mặt nạ có thể được nhóm (batched) với hình dạng `(batch_size, sequence_length)` hoặc không nhóm với hình dạng `(sequence_length,)`.

generator (`torch.Generator`, *tùy chọn*) : Một [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) để làm cho quá trình sinh ra kết quả tất định. return_dict: Có nên trả về một lớp con của [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple đơn thuần hay không.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** `UnivNetModelOutput` hoặc `tuple(torch.Tensor)`

Một `UnivNetModelOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([UnivNetConfig](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetConfig)) và đầu vào.

Phương thức forward của [UnivNetModel](/docs/transformers/v5.23.0/vi/model_doc/univnet#transformers.UnivNetModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **biên độ sóng** (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) -- Các biên độ sóng âm thanh đầu ra 1D (mô-nô) được xử lý theo lô.
- **waveform_lengths** (`torch.Tensor` có hình dạng `(batch_size,)`) -- Độ dài theo số mẫu của từng waveform chưa được đệm trong `waveforms`.

Ví dụ:

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

