# DAC

## Ikhtisar

Model DAC diusulkan dalam [Descript Audio Codec: High-Fidelity Audio Compression with Improved RVQGAN](https://huggingface.co/papers/2306.06546) oleh Rithesh Kumar, Prem Seetharaman, Alejandro Luebs, Ishaan Kumar, dan Kundan Kumar.

Model Descript Audio Codec (DAC) adalah alat yang ampuh untuk mengompresi data audio, sehingga sangat efisien untuk penyimpanan dan transmisi. Dengan mengompresi audio 44,1 KHz menjadi token pada bandwidth hanya 8kbps, model DAC memungkinkan pemrosesan audio berkualitas tinggi sambil secara signifikan mengurangi jejak data. Hal ini sangat berguna dalam skenario di mana bandwidth terbatas atau ruang penyimpanan sangat berharga, seperti dalam aplikasi streaming, konferensi jarak jauh, dan pengarsipan dataset audio besar.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Model bahasa telah digunakan secara sukses untuk memodelkan sinyal alami, seperti gambar, ucapan, dan musik. Komponen kunci dari model-model ini adalah model kompresi neural berkualitas tinggi yang mampu mengompres sinyal alami berdimensi tinggi menjadi token diskrit berdimensi lebih rendah. Untuk tujuan tersebut, kami memperkenalkan algoritma kompresi audio neural universal ber-fidelitas tinggi yang mencapai kompresi ~90x untuk audio 44,1 KHz menjadi token pada bandwidth hanya 8kbps. Kami mencapai hal ini dengan menggabungkan kemajuan dalam generasi audio ber-fidelitas tinggi dengan teknik kuantisasi vektor yang lebih baik dari domain gambar, serta peningkatan pada kerugian adversarial dan rekonstruksi. Kami mengompres semua domain (ucapan, lingkungan, musik, dll.) dengan satu model universal, sehingga membuatnya sangat aplikatif untuk pemodelan generatif semua audio. Kami membandingkan dengan algoritma kompresi audio pesaing, dan menemukan bahwa metode kami secara signifikan melampaui mereka. Kami menyediakan ablasasi yang menyeluruh untuk setiap pilihan desain, serta kode sumber terbuka dan bobot model yang telah dilatih. Kami berharap pekerjaan kami dapat meletakkan dasar untuk generasi berikutnya dari pemodelan audio ber-fidelitas tinggi.*

Model ini disumbangkan oleh [Kamil Akesbi](https://huggingface.co/kamilakesbi). Kode aslinya dapat ditemukan [di sini](https://github.com/descriptinc/descript-audio-codec/tree/main?tab=readme-ov-file).

## Struktur model

Model Descript Audio Codec (DAC) terstruktur menjadi tiga tahap yang berbeda:

1. Model Encoder: Tahap ini mengompresi audio input, mengurangi ukurannya sambil mempertahankan informasi penting.
2. Model Residual Vector Quantizer (RVQ): Bekerja bersama dengan encoder, model ini mengkuantisasi kode laten dari audio, menyempurnakan kompresi, dan memastikan rekonstruksi berkualitas tinggi.
3. Model Decoder: Tahap akhir ini merekonstruksi audio dari bentuk terkompresinya, mengembalikannya ke kondisi yang sangat menyerupai input asli.

## Contoh penggunaan

Berikut adalah contoh singkat tentang cara mengkodekan dan mendekodekan audio menggunakan model ini:

```python
from datasets import Audio, load_dataset

from transformers import AutoProcessor, DacModel

librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

model = DacModel.from_pretrained("descript/dac_16khz", device_map="auto")
processor = AutoProcessor.from_pretrained("descript/dac_16khz")
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"])
# Get the intermediate audio codes
audio_codes = encoder_outputs.audio_codes
# Reconstruct the audio from its quantized representation
audio_values = model.decode(encoder_outputs.quantized_representation)
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_values
```

## DacConfig[[transformers.DacConfig]]

#### transformers.DacConfig[[transformers.DacConfig]]

```python
transformers.DacConfig(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, encoder_hidden_size: int = 64, downsampling_ratios: list[int] | tuple[int, ...] = (2, 4, 8, 8), decoder_hidden_size: int = 1536, n_codebooks: int = 9, codebook_size: int = 1024, codebook_dim: int = 8, quantizer_dropout: float | int = 0.0, commitment_loss_weight: float = 0.25, codebook_loss_weight: float = 1.0, sampling_rate: int = 16000)
```

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

**Parameter:**

encoder_hidden_size (`int`, *opsional*, defaultnya `64`) : Dimensi dari representasi tersembunyi.

downsampling_ratios (`list[int]`, *opsional*, defaultnya `[2, 4, 8, 8]`) : Rasio untuk downsampling di encoder. Rasio ini digunakan dalam urutan terbalik untuk upsampling di decoder.

decoder_hidden_size (`int`, *opsional*, defaultnya `1536`) : Dimensi dari representasi tersembunyi.

n_codebooks (`int`, *opsional*, defaultnya `9`) : Jumlah codebook paralel yang digunakan oleh model.

codebook_size (`int`, *opsional*, defaultnya `1024`) : Jumlah codebook paralel yang digunakan oleh model.

codebook_dim (`int`, *opsional*, defaultnya `8`) : Dimensi dari setiap vektor embedding codebook.

quantizer_dropout (`bool`, *opsional*, default 0) : Apakah akan menerapkan dropout pada kuantizer.

commitment_loss_weight (`float`, *opsional*, default 0.25) : Bobot dari suku komitmen dalam fungsi kerugian VQVAE.

codebook_loss_weight (`float`, *opsional*, default 1.0) : Bobot istilah loss codebook dalam fungsi loss VQVAE.

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

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DacModel. Kelas ini digunakan untuk membuat instans model Dac sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [descript/dac_16khz](https://huggingface.co/descript/dac_16khz)

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 DacModel, DacConfig

>>> # Initializing a "descript/dac_16khz" style configuration
>>> configuration = DacConfig()

>>> # Initializing a model (with random weights) from the "descript/dac_16khz" style configuration
>>> model = DacModel(configuration)

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

## DacFeatureExtractor[[transformers.DacFeatureExtractor]]

#### transformers.DacFeatureExtractor[[transformers.DacFeatureExtractor]]

```python
transformers.DacFeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, hop_length: int = 512, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/feature_extraction_dac.py#L26)

**Parameter:**

feature_size (`int`, *opsional*, default 1) : Dimensi fitur dari fitur yang diekstrak. Gunakan 1 untuk mono, 2 untuk stereo.

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

padding_value (`float`, *opsional*, default 0.0) : Nilai yang digunakan untuk padding.

hop_length (`int`, *opsional*, defaultnya 512) : Panjang tumpang tindih antara jendela yang berurutan.

Membangun ekstraktor fitur Dac.

Feature extractor ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/main/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.DacFeatureExtractor.__call__]]

```python
__call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/feature_extraction_dac.py#L57)

**Parameter:**

raw_audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Urutan atau batch dari urutan yang akan diproses. Setiap urutan dapat berupa array numpy, daftar nilai float, daftar array numpy, atau daftar dari daftar nilai float. Array numpy harus memiliki bentuk `(num_samples,)` untuk audio mono (`feature_size = 1`), atau `(2, num_samples)` untuk audio stereo (`feature_size = 2`).

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/main/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `True`) : Pilih strategi untuk melakukan padding pada urutan yang dikembalikan (sesuai sisi padding dan indeks padding model) di antara: - `True` atau `'longest'`: Lakukan padding hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Lakukan padding 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`, *opsional*, defaultnya `False`) : Mengaktifkan pemotongan untuk memotong urutan input yang lebih panjang dari `max_length` menjadi `max_length`.

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

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

sampling_rate (`int`, *opsional*) : Laju pengambilan sampel di mana input `audio` diambil. Sangat disarankan untuk meneruskan `sampling_rate` pada panggilan forward untuk mencegah kesalahan yang tidak terdeteksi.

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

## DacModel[[transformers.DacModel]]

#### transformers.DacModel[[transformers.DacModel]]

```python
transformers.DacModel(config: DacConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L563)

**Parameter:**

config ([DacConfig](/docs/transformers/main/id/model_doc/dac#transformers.DacConfig)) : 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 DAC (Descript Audio Codec).

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.

#### decode[[transformers.DacModel.decode]]

```python
decode(quantized_representation: typing.Optional[torch.Tensor] = None, audio_codes: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L609)

**Parameter:**

quantized_representation (`torch.Tensor` dengan bentuk `(batch_size, dimension, time_steps)`, *opsional*) : Representasi kontinu terkuantisasi dari input.

audio_codes (`torch.Tensor` dengan bentuk `(batch_size, num_codebooks, time_steps)`, *opsional*) : Indeks codebook untuk setiap codebook, yang merepresentasikan representasi diskrit terkuantisasi dari input. Parameter ini harus disediakan jika Anda ingin mendekode langsung dari kode audio (hal ini akan menimpa quantized_representation).

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `DacDecoderOutput` alih-alih tuple biasa.

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

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

- **audio_values** (`torch.Tensor` dengan bentuk `(batch_size, input_length)`, *opsional*) -- Nilai audio yang telah didekode, diperoleh menggunakan bagian decoder dari Dac.

#### encode[[transformers.DacModel.encode]]

```python
encode(input_values: Tensor, n_quantizers: int | None = None, return_dict: bool | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L582)

**Parameter:**

input_values (`torch.Tensor of shape `(batch_size, 1, time_steps)`) : Data audio input untuk dienkapsulasi,

n_quantizers (`int`, *opsional*) : Jumlah kuantizer yang akan digunakan. Jika None, semua kuantizer akan digunakan. Nilai default adalah None.

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

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

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

- **loss** (`torch.Tensor`, *opsional*) -- Loss dari model encoder, yang terdiri dari kombinasi berbobot dari loss commitment dan codebook.
- **quantized_representation** (`torch.Tensor` dengan bentuk `(batch_size, dimension, time_steps)`, *opsional*) -- Representasi kontinu terkuantisasi dari input.
- **audio_codes** (`torch.Tensor` dengan bentuk `(batch_size, num_codebooks, time_steps)`, *opsional*) -- Indeks codebook untuk setiap codebook (representasi diskrit terkuantisasi dari input).
- **projected_latents** (`torch.Tensor` dengan bentuk `(batch_size, num_codebooks * dimension, time_steps)`, *opsional*) -- Latents yang diproyeksikan (representasi kontinu dari input sebelum kuantisasi).

#### forward[[transformers.DacModel.forward]]

```python
forward(input_values: Tensor, n_quantizers: int | None = None, return_dict: bool | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L642)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, 1, time_steps)`) : Data audio untuk dienkod.

n_quantizers (`int`, *opsional*) : Jumlah kuantizer yang akan digunakan. Jika `None`, semua kuantizer digunakan. Nilai default adalah `None`.

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

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

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

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

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

- **loss** (`torch.Tensor`, *opsional*) -- Loss dari model encoder, yang terdiri dari kombinasi berbobot dari commitment loss dan codebook loss.
- **audio_values** (`torch.Tensor` dengan bentuk `(batch_size, input_length)`) -- Data audio yang direkonstruksi.
- **quantized_representation** (`torch.Tensor` dengan bentuk `(batch_size, dimension, time_steps)`) -- Representasi kontinu terkuantisasi dari input.
- **audio_codes** (`torch.LongTensor` dengan bentuk `(batch_size, num_codebooks, time_steps)`) -- Indeks codebook untuk setiap codebook (representasi diskrit terkuantisasi dari input).
- **projected_latents** (`torch.Tensor` dengan bentuk `(batch_size, num_codebooks * dimension, time_steps)`) -- Laten yang diproyeksikan (representasi kontinu dari input sebelum kuantisasi).

Contoh:

```python
>>> from datasets import load_dataset, Audio
>>> from transformers import DacModel, AutoProcessor
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> model = DacModel.from_pretrained("descript/dac_16khz")
>>> processor = AutoProcessor.from_pretrained("descript/dac_16khz")
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt")

>>> encoder_outputs = model.encode(inputs["input_values"])
>>> # Get the intermediate audio codes
>>> audio_codes = encoder_outputs.audio_codes
>>> # Reconstruct the audio from its quantized representation
>>> audio_values = model.decode(encoder_outputs.quantized_representation)
>>> # or the equivalent with a forward pass
>>> audio_values = model(inputs["input_values"]).audio_values
```