# Tokenizer Higgs Audio V2

## Ikhtisar

- Frame Rate Rendah: Pada 25 fps, tokenizer kami mengurangi setengah frame rate dari banyak baseline sambil tetap mempertahankan kualitas audio yang tinggi.
- Pelatihan 24 kHz Terpadu: Kami mencampurkan klip ucapan, musik, dan peristiwa suara dalam satu model, menangkap detail semantik dan akustik, yang sangat memfasilitasi pelatihan model bahasa audio.
- Inferensi Cepat: Dengan menghindari langkah difusi, encoder/decoder kami memproses batch dengan cepat, menjadikannya praktis untuk tugas real-time atau skala besar.

**Arsitektur Model:**

    

## Penggunaan

```python
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, HiggsAudioV2TokenizerModel

# load model and feature extractor
model_id = "eustlb/higgs-audio-v2-tokenizer"
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = HiggsAudioV2TokenizerModel.from_pretrained(model_id, device_map="auto")

# load audio sample
dummy_dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dummy_dataset = dummy_dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = dummy_dataset[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)

# encode and decode
encoder_outputs = model.encode(inputs["input_values"])
decoder_outputs = model.decode(encoder_outputs.audio_codes)
audio_values = decoder_outputs.audio_values

# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_values
```

## HiggsAudioV2TokenizerConfig[[transformers.HiggsAudioV2TokenizerConfig]]

#### transformers.HiggsAudioV2TokenizerConfig[[transformers.HiggsAudioV2TokenizerConfig]]

```python
transformers.HiggsAudioV2TokenizerConfig(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, target_bandwidths: list[int | float] | tuple[int | float, ...] = (0.5, 1, 1.5, 2, 4), sample_rate: int = 24000, kernel_size: int = 3, channel_ratios: list[int] | tuple[int, ...] = (1, 1), strides: list[int] | tuple[int, ...] = (1, 1), block_dilations: list[int] | tuple[int, ...] = (1, 1), unit_kernel_size: int = 3, codebook_size: int = 1024, codebook_dim: int = 64, initializer_range: float = 0.02, acoustic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_sample_rate: int = 16000, downsample_factor: int = 320)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/configuration_higgs_audio_v2_tokenizer.py#L34)

**Parameter:**

target_bandwidths (`List[float]`, *opsional*, defaultnya `[0.5, 1, 1.5, 2]`) : Rentang bandwidth (dalam kbps) yang berbeda yang dapat digunakan model untuk mengkodekan audio.

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

kernel_size (`int`, *opsional*, defaultnya 3) : Ukuran kernel untuk konvolusi semantik awal.

channel_ratios (`List[float]`, *opsional*, defaultnya `[1, 1]`) : Faktor ekspansi untuk jumlah kanal output di setiap blok semantik.

strides (`List[int]`, *opsional*, defaultnya `[1, 1]`) : Strides untuk setiap blok semantic encoder.

block_dilations (`List[int]`, *opsional*, defaultnya `[1, 1]`) : Faktor dilatasi untuk unit residual dalam blok semantik.

unit_kernel_size (`int`, *opsional*, default 3) : Ukuran kernel di dalam setiap ResidualUnit pada blok semantik.

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

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

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

acoustic_model_config (`Union[Dict, AutoConfig]`, *opsional*) : Sebuah instance dari konfigurasi untuk model akustik (DAC).

semantic_model_config (`Union[Dict, AutoConfig]`, *opsional*) : Sebuah instance dari objek konfigurasi untuk model semantik (HuBERT).

semantic_sample_rate (`int`, *opsional*, default 16000) : Laju sampling yang diharapkan oleh model semantik untuk input audio, dalam hertz (Hz).

downsample_factor (`int`, *opsional*, default 320) : Faktor downsampling untuk fitur semantik.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari HiggsAudioV2TokenizerModel. Kelas ini digunakan untuk membuat instans model Higgs Audio V2 Tokenizer sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [bosonai/higgs-audio-v2-tokenizer](https://huggingface.co/bosonai/higgs-audio-v2-tokenizer)

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 HiggsAudioV2TokenizerModel, HiggsAudioV2TokenizerConfig

>>> # Initializing configuration
>>> configuration = HiggsAudioV2TokenizerConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = HiggsAudioV2TokenizerModel(configuration)

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

## HiggsAudioV2TokenizerModel[[transformers.HiggsAudioV2TokenizerModel]]

#### transformers.HiggsAudioV2TokenizerModel[[transformers.HiggsAudioV2TokenizerModel]]

```python
transformers.HiggsAudioV2TokenizerModel(config: HiggsAudioV2TokenizerConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L456)

**Parameter:**

config ([HiggsAudioV2TokenizerConfig](/docs/transformers/main/id/model_doc/higgs_audio_v2_tokenizer#transformers.HiggsAudioV2TokenizerConfig)) : 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 codec audio neural HiggsAudioV2Tokenizer.

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.HiggsAudioV2TokenizerModel.decode]]

```python
decode(audio_codes: Tensor, return_dict: bool | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L564)

**Parameter:**

audio_codes (`torch.LongTensor` dengan bentuk `(batch_size, num_quantizers, codes_length)`) : Indeks kode diskrit yang dihitung menggunakan `model.encode`.

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

**Mengembalikan:**

Nilai audio terdekoding dengan bentuk `(batch_size, channels, num_samples)` yang diperoleh menggunakan bagian decoder dari HiggsAudioV2Tokenizer.

#### encode[[transformers.HiggsAudioV2TokenizerModel.encode]]

```python
encode(input_values: Tensor, bandwidth: float | None = None, return_dict: bool | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L512)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, channels, num_samples)`) : Nilai float dari waveform audio input.

bandwidth (`float`, *opsional*) : Bandwidth target dalam (kbps) hanya mendukung nilai yang ada di `config.target_bandwidths`. Defaultnya adalah bandwidth tertinggi yang tersedia, yaitu `4.0` kbps.

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

**Mengembalikan:**

`torch.LongTensor` dengan bentuk `(batch_size, num_quantizers, codes_length)` yang berisi kode audio terenkripsi diskrit.

#### forward[[transformers.HiggsAudioV2TokenizerModel.forward]]

```python
forward(input_values: Tensor, audio_codes: typing.Optional[torch.Tensor] = None, bandwidth: float | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L592)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, channels, num_samples)`) : Nilai float mentah dari waveform audio input.

audio_codes (`torch.LongTensor` dengan bentuk `(batch_size, num_quantizers, codes_length)` : Indeks kode diskrit yang dihitung menggunakan `model.encode`.

bandwidth (`float`, *opsional*) : Bandwidth target dalam kbps. Harus salah satu dari `config.target_bandwidths`. Secara default menggunakan bandwidth tertinggi yang tersedia.

bandwidth (`float`, *opsional*) : Bandwidth target dalam kbps. Harus salah satu dari `config.target_bandwidths`. Secara default menggunakan bandwidth tertinggi yang tersedia.

**Mengembalikan:** `HiggsAudioV2TokenizerOutput` atau tuple `(audio_codes, audio_values)`

- `audio_codes` dengan bentuk `(batch_size, num_quantizers, codes_length)`: kode diskrit terkuantisasi.
- `audio_values` dengan bentuk `(batch_size, channels, num_samples)`: gelombang audio yang direkonstruksi berdasarkan kode.

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

Contoh:

```python
>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, HiggsAudioV2TokenizerModel

>>> model_id = "hf-audio/higgs_audio_v2_tokenizer-hubert-librispeech"
>>> model = HiggsAudioV2TokenizerModel.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> audio_sample = dataset[0]['audio']['array']

>>> inputs = feature_extractor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values
```