# UnivNet

## Genel Bakış

UnivNet modeli, Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin ve Juntae Kim tarafından [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) makalesinde önerilmiştir. UnivNet modeli, yüksek sadakatli ses dalga formları sentezlemek üzere eğitilen bir üretken düşman ağdır (GAN). `transformers` içinde paylaşılan UnivNet modeli, koşullandırmalı log-mel spektrogramını ve isteğe bağlı gürültü dizisini bir ses dalga formuna (ör. bir vokoder) eşleyen *generator*'dır. Çıkarım için yalnızca generator gereklidir. `generator`'u eğitmek için kullanılan *discriminator* uygulanmamıştır.

Makalenin özeti aşağıdaki gibidir:

*Çoğu sinirsel vokoder, dalga formları üretmek için bant sınırlı mel-spektrogramlar kullanır. Tam bant spektral özellikler girdi olarak kullanılırsa, vokodere mümkün olan en yüksek düzeyde akustik bilgi sağlanabilir. Ancak tam bant mel-spektrogramlar kullanan bazı modellerde, keskin olmayan spektrogramların üretilmesiyle sonuçlanan bir aşırı yumuşatma (over-smoothing) sorunu ortaya çıkar. Bu sorunu ele almak için, gerçek zamanlı olarak yüksek sadakatli dalga formları sentezleyen UnivNet adlı bir sinirsel vokoder öneriyoruz. Ses aktivitesi algılama alanındaki çalışmalardan ilham alarak, çeşitli parametre setleri kullanılarak hesaplanan çoklu doğrusal spektrogram genliklerini kullanan çok çözünürlüklü bir spektrogram ayrıştırıcı (discriminator) ekledik. Girdi olarak tam bant mel-spektrogramlar kullandığımızda, girdi olarak çoklu çözünürlüklü spektrogramlar kullanan bir ayrıştırıcı ekleyerek yüksek çözünürlüklü sinyaller üretmeyi hedefliyoruz. Yüzlerce konuşmacıya ait bilgiler içeren bir veri seti üzerinde yapılan değerlendirmede, UnivNet, hem bilinen hem de bilinmeyen konuşmacılar için rakip modeller arasında hem nesnel hem de öznel olarak en iyi sonuçları elde etti. Metinden sese (text-to-speech) en iyi öznel puanı da içeren bu sonuçlar, sıfırdan eğitim gerektirmeden yeni konuşmacılara hızlı uyarlama potansiyelini göstermektedir.*

İpuçları:

- [UnivNetModel.forward()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetModel.forward) için `noise_sequence` argümanı, `input_features` argümanının uzunluk boyutuyla (1. boyut) eşleşen `noise_length` değerine sahip, `([batch_size], noise_length, model.config.model_in_channels)` biçiminde standart Gauss gürültüsü (örneğin `torch.randn` ile üretilen) olmalıdır. Sağlanmazsa rastgele üretilir; ileri geçişin yeniden üretilebilmesi için `generator` argümanına bir `torch.Generator` sağlanabilir. (Not: [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) varsayılan olarak üretilmiş gürültüyü döndürür, bu nedenle `noise_sequence` değerini manuel olarak üretmeye gerek yoktur.)
- [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) tarafından eklenen dolgu, aşağıdaki kullanım örneğinde gösterildiği gibi `UnivNetFeatureExtractor.batch_decode()` yöntemi aracılığıyla [UnivNetModel](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetModel) çıktısından kaldırılabilir.
- Her dalga formunun sonunu sessizlikle doldurmak, üretilen ses örneğinin sonunda oluşabilecek artefaktları azaltabilir. Bunu yapmak için [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) fonksiyonuna `pad_end = True` parametresini iletmek yeterlidir. Daha fazla ayrıntı için [bu sorunu](https://github.com/seungwonpark/melgan/issues/8) inceleyin.

Kullanım Örneği:

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

Bu model [dg845](https://huggingface.co/dg845) tarafından katkıda bulunmuştur. Bilgime göre resmi bir kod yayını yoktur, ancak ön eğitilmiş denetim noktalarıyla birlikte [burada](https://github.com/maum-ai/univnet#pre-trained-model) [maum-ai/univnet](https://github.com/maum-ai/univnet) adresinde resmi olmayan bir uygulama bulunabilir.

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

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

**Parametreler:**

model_in_channels (`int`, *isteğe bağlı*, varsayılan 64) : UnivNet artık (residual) ağı için giriş kanal sayısı. Bu değer `noise_sequence.shape[1]` ile ve [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) sınıfında kullanılan değerle eşleşmelidir.

model_hidden_channels (`int`, *isteğe bağlı*, varsayılan 32) : UnivNet artımsal ağında her artımsal bloğun gizli kanal sayısı.

num_mel_bins (`int`, *isteğe bağlı*, varsayılan 100) : Koşullama log-mel spektrogramındaki frekans kutusu sayısı. Bu, [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) sınıfında kullanılan değerle eşleşmelidir.

resblock_kernel_sizes (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `[3, 3, 3]`) : UnivNet artımsal ağındaki 1B konvolüsyonlu katmanların çekirdek boyutlarını tanımlayan tamsayılardan oluşan bir demet. `resblock_kernel_sizes`'in uzunluğu, resnet bloklarının sayısını belirler ve `resblock_stride_sizes` ile `resblock_dilation_sizes`'in uzunluğuyla eşleşmelidir.

resblock_stride_sizes (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `[8, 8, 4]`) : UnivNet artımsal ağındaki 1B konvolüsyon katmanlarının adım boyutlarını tanımlayan tamsayılardan oluşan bir demet. `resblock_stride_sizes`'in uzunluğu, `resblock_kernel_sizes` ve `resblock_dilation_sizes`'in uzunluğuyla eşleşmelidir.

resblock_dilation_sizes (`tuple[tuple[int]]` veya `list[list[int]]`, *opsiyonel*, varsayılan değeri `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : UnivNet artımsal ağındaki seyreltilmiş 1D konvolüsyonlu katmanların seyreltme oranlarını tanımlayan iç içe geçmiş bir tamsayı tuple'ı. `resblock_dilation_sizes`'in uzunluğu, `resblock_kernel_sizes` ve `resblock_stride_sizes`'in uzunluğuyla eşleşmelidir. `resblock_dilation_sizes` içindeki her iç içe geçmiş listenin uzunluğu, her resnet bloğu başına konvolüsyonlu katman sayısını belirler.

kernel_predictor_num_blocks (`int`, *isteğe bağlı*, varsayılan 3) : UnivNet artık ağında her konum değişkeni konvolüsyon katmanı için çekirdek ve önyargıyı hesaplayan çekirdek öngörücü ağdaki artık blok sayısı.

kernel_predictor_hidden_channels (`int`, *isteğe bağlı*, varsayılan 64) : Çekirdek öngörücü ağında her artımsal blok için gizli kanal sayısı.

kernel_predictor_conv_size (`int`, *isteğe bağlı*, varsayılan 3) : Çekirdek tahmin ağındaki her 1D konvolüsyonel katmanın çekirdek boyutu.

kernel_predictor_dropout (`float`, *isteğe bağlı*, varsayılan 0.0) : Çekirdek öngörücü ağında her artımsal blok için dropout olasılığı.

initializer_range (`float`, *opsiyonel*, varsayılan `0.01`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

leaky_relu_slope (`float`, *opsiyonel*, varsayılan 0.2) : Leaky ReLU aktivasyonunun kullandığı negatif eğimin açısı.

Bu, bir UnivNetModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Univnet modelinin örneklenmesi ve model mimarisinin tanımlanması için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev) yapılandırmasına benzer bir yapılandırma elde edilmesini sağlar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

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

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

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 1) : Çıkarılan özelliklerin boyutu.

sampling_rate (`int`, *opsiyonel*, varsayılan 24000) : Ses dosyalarının dijitalleştirileceği örneklem hızı, hertz (Hz) cinsinden ifade edilir.

padding_value (`float`, *opsiyonel*, varsayılan 0.0) : [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) içindeki `padding` argümanıyla tanımlanan dolgu stratejisi uygulanırken kullanılacak dolgu değeri. Ses sessizliğine karşılık gelmelidir. `__call__` içindeki `pad_end` argümanı da bu dolgu değerini kullanacaktır.

do_normalize (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdi üzerinde Tacotron 2 normalizasyonu uygulanıp uygulanmayacağı. Normalizasyon, bazı modellerde performansı önemli ölçüde iyileştirebilir.

num_mel_bins (`int`, *isteğe bağlı*, varsayılan 100) : Çıkarılan spektrogram özelliklerindeki mel-frekans kutu sayısı. Bu, `UnivNetModel.config.num_mel_bins` ile eşleşmelidir.

hop_length (`int`, *opsiyonel*, varsayılan 256) : Kayan pencereler arasındaki doğrudan örnek sayısı. Birçok makalede "shift" olarak da adlandırılır. Dikkat edin, bu, `hop_length` değerini ms cinsinden alan [SpeechT5FeatureExtractor](/docs/transformers/main/tr/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) gibi diğer ses özellik çıkarıcılarından farklıdır.

win_length (`int`, *opsiyonel*, varsayılan 1024) : Her kayan pencere için doğrudan örnek sayısı. Not: Bu, `win_length` değerini ms cinsinden alan [SpeechT5FeatureExtractor](/docs/transformers/main/tr/model_doc/speecht5#transformers.SpeechT5FeatureExtractor) gibi diğer ses özellik çıkarıcılarından farklıdır.

win_function (`str`, *isteğe bağlı*, varsayılan `"hann_window"`) : Pencereleme için kullanılan pencere fonksiyonunun adı, `torch.{win_function}` üzerinden erişilebilir olmalıdır

filter_length (`int`, *isteğe bağlı*, varsayılan 1024) : Kullanılacak FFT bileşenlerinin sayısı. `None` ise, bu değer `transformers.audio_utils.optimal_fft_length` kullanılarak belirlenir.

max_length_s (`int`, *isteğe bağlı*, varsayılan 10) : Modelin saniye cinsinden maksimum giriş uzunluğu. Bu, sesin dolgu (padding) işlemi için kullanılır.

fmin (`float`, *isteğe bağlı*, varsayılan 0.0) : Hz cinsinden minimum mel frekansı.

fmax (`float`, *isteğe bağlı*) : Hz cinsinden maksimum mel frekansı. Ayarlanmazsa, varsayılan olarak `sampling_rate / 2` değerini alır.

mel_floor (`float`, *isteğe bağlı*, varsayılan 1e-09) : Mel frekans bankalarının minimum değeri. Not: [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor)'ın `mel_floor`'u kullanma şekli, [transformers.audio_utils.spectrogram()](/docs/transformers/main/tr/internal/audio_utils#transformers.audio_utils.spectrogram) içindeki kullanımdan farklıdır.

center (`bool`, *isteğe bağlı*, varsayılan `False`) : `t` çerçevesinin `t * hop_length` zamanı etrafında ortalanması için dalga formunun dolgu (padding) uygulanacak olup olmayacağını belirtir. `False` ise, `t` çerçevesi `t * hop_length` zamanında başlar.

compression_factor (`float`, *opsiyonel*, varsayılan 1.0) : Spektral normalizasyon sırasında dinamik aralık sıkıştırması için çarpımsal sıkıştırma faktörü.

compression_clip_val (`float`, *opsiyonel*, varsayılan 1e-05) : Spektral normalizasyon sırasında dinamik aralık sıkıştırması uygulanmadan önce dalga formuna uygulanan kırpma değeri.

normalize_min (`float`, *opsiyonel*, varsayılan -11.512925148010254) : Tacotron 2 tarzı doğrusal normalizasyon için kullanılan minimum değer. Varsayılan, Tacotron 2 uygulamasındaki orijinal değerdir.

normalize_max (`float`, *opsiyonel*, varsayılan 2.3143386840820312) : Tacotron 2 tarzı doğrusal normalizasyon için kullanılan maksimum değer. Varsayılan, Tacotron 2 uygulamasındaki orijinal değerdir.

model_in_channels (`int`, *isteğe bağlı*, varsayılan 64) : [UnivNetModel](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetModel) modeline giren giriş kanal sayısı. Bu, `UnivNetModel.config.model_in_channels` ile eşleşmelidir.

pad_end_length (`int`, *isteğe bağlı*, varsayılan 10) : Her dalga formunun sonunu dolgu ile dolduruyorsanız, eklenmesi gereken örneklerin spektrogram çerçevesi cinsinden sayısı. Eklenen örnek sayısı `pad_end_length * hop_length` olacaktır.

return_attention_mask (`bool`, *isteğe bağlı*, varsayılan `True`) : [__call__()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__)'in `attention_mask` döndürüp döndürmeyeceğini belirtir.

UnivNet özellik çıkarıcısı oluşturur.

Bu sınıf, ham konuşma verisinden kısa zamanlı Fourier dönüşümü (STFT) kullanarak log-mel-filtre bankası özelliklerini çıkarır. STFT uygulaması TacoTron 2 ve Hifi-GAN'daki uygulamayı takip eder.

Bu özellik çıkarıcı, ana yöntemlerin çoğunu içeren [SequenceFeatureExtractor](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

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

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

**Parametreler:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Dolgusu yapılacak dizi veya dizi partisi. Her dizi, bir numpy dizisi, bir float değerleri listesi, bir numpy dizileri listesi veya float değerleri listeleri listesi olabilir. Tek kanallı ses olmalıdır, stereo değil; yani her zaman adımı için tek bir float.

sampling_rate (`int`, *isteğe bağlı*) : `raw_speech` girdisinin örneklenmiş olduğu örneklem hızı. Sessiz hataları önlemek ve otomatik konuşma tanıma hattına izin vermek için forward çağrısında `sampling_rate` parametresinin geçirilmesi şiddetle önerilir.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/main/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `True`) : Girdi `raw_speech` dalga formlarını (modelin dolgusu tarafına ve dolgu indeksine göre) aşağıdakilerden birine göre doldurmak için bir strateji seçin:  - `True` veya `'longest'`: Batch'teki en uzun dizinin uzunluğuna kadar doldurun (yalnızca tek bir dizi sağlandıysa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum girdi uzunluğuna kadar doldurun. - `False` veya `'do_not_pad'` (varsayılan): Dolgu yok (yani, farklı uzunluklarda dizilere sahip bir batch çıktı olarak verilebilir).  `pad_end = True` ise, bu dolgu `padding` stratejisi uygulanmadan önce gerçekleşir.

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

truncation (`bool`, *isteğe bağlı*, varsayılan `True`) : `max_length`'den uzun giriş dizilerini `max_length`'e kısaltmak için kesme işlemini etkinleştirir.

pad_to_multiple_of (`int`, *opsiyonel*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Cores kullanımını etkinleştirmek veya 128'in katı olan dizi uzunluklarından faydalanan TPU'larda özellikle faydalıdır.

return_noise (`bool`, *isteğe bağlı*, varsayılan `True`) : [UnivNetModel.forward()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetModel.forward) içinde kullanılmak üzere bir gürültü dalgası üretilip döndürülüp döndürülmemesi.

generator (`numpy.random.Generator`, *isteğe bağlı*, varsayılan `None`) : Gürültü üretirken kullanılacak isteğe bağlı bir `numpy.random.Generator` rastgele sayı üreteci.

pad_end (`bool`, *isteğe bağlı*, varsayılan `False`) : Her dalga formunun sonunu sessizlikle doldurup doldurmayacağını belirtir. Bu, üretilen ses örneğinin sonunda oluşabilecek artefaktları azaltmaya yardımcı olabilir; daha fazla ayrıntı için https://github.com/seungwonpark/melgan/issues/8 adresine bakın. Bu dolgu işlemi, `padding` parametresinde belirtilen dolgu stratejisi uygulanmadan önce yapılır.

pad_length (`int`, *isteğe bağlı*, varsayılan `None`) : Her dalga formunun sonunu dolgu ile dolduruyorsanız, dolgunun spektrogram çerçevesi cinsinden uzunluğu. Ayarlanmazsa, bu değer varsayılan olarak `self.config.pad_end_length` olur.

do_normalize (`bool`, *isteğe bağlı*) : Girdi üzerinde Tacotron 2 normalizasyonu uygulanacak mı? Normalizasyon, bazı modellerde performansı önemli ölçüde iyileştirebilir. Ayarlanmazsa, bu değer `self.config.do_normalize` varsayılanını kullanır.

return_attention_mask (`bool`, *isteğe bağlı*) : Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan bırakılırsa, ilgili feature_extractor'ın varsayılanına göre dikkat maskesi döndürülür. [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, Python tamsayı listesi yerine tensörler döndürülür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.np.array` nesnelerini döndürür. - `'np'`: Numpy `np.ndarray` nesnelerini döndürür.

Bir veya birden fazla diziyi model için özelliklendirmek ve hazırlamak için ana yöntem.

## UnivNetModel[[transformers.UnivNetModel]]

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

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

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

**Parametreler:**

config ([UnivNetConfig](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Üzerinde herhangi bir özel head olmadan ham hidden-states üreten çıplak Univnet Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

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

**Parametreler:**

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) kullanılarak elde edilebilir. Ayrıntılar için [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__)'a bakın (`processor_class`, sesleri işlemek için [UnivNetFeatureExtractor](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetFeatureExtractor) kullanır).

noise_sequence (`torch.Tensor`, *isteğe bağlı*) : Standart Gauss gürültüsünden oluşan bir gürültü dizisi içeren Tensor. `(batch_size, sequence_length, config.model_in_channels)` biçiminde toplu (batched) veya (sequence_length, config.model_in_channels) biçiminde toplu olmayan (un-batched) olabilir. Sağlanmazsa, rastgele oluşturulur.

padding_mask (`torch.BoolTensor`, *isteğe bağlı*) : Her dizinin hangi kısımlarının dolgu (padding) olduğunu gösteren maske. Maske değerleri `[0, 1]` aralığında seçilir:  - **maske uygulanmamış** jetonlar için 1 - **maske uygulanmış** jetonlar için 0  Maske, `(batch_size, sequence_length)` biçiminde toplu (batched) veya `(sequence_length,)` biçiminde toplu olmayan (un-batched) olabilir.

generator (`torch.Generator`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir [torch üreteci](https://pytorch.org/docs/stable/generated/torch.Generator.html). return_dict: Düz bir tuple yerine bir [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) alt sınıfı döndürülüp döndürülmemesi.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `UnivNetModelOutput` veya `tuple(torch.Tensor)`

Çeşitli öğelerden oluşan bir `UnivNetModelOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); bu öğeler yapılandırmaya ([UnivNetConfig](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetConfig)) ve girdilere bağlı olarak değişir.

[UnivNetModel](/docs/transformers/main/tr/model_doc/univnet#transformers.UnivNetModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **dalga formları** (`torch.Tensor`, şekli `(batch_size, sequence_length)`) -- Toplu 1B (tek kanal) çıkış ses dalga formları.
- **waveform_lengths** (`torch.Tensor`, şekli `(batch_size,)`) -- `waveforms` içindeki her dolgu yapılmamış dalga formunun örnek cinsinden toplu uzunluğu.

Örnek:

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