# Wav2Vec2

## Ikhtisar

Model Wav2Vec2 diusulkan dalam [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://huggingface.co/papers/2006.11477) oleh Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami menunjukkan untuk pertama kalinya bahwa pembelajaran representasi yang kuat hanya dari audio ucapan, diikuti dengan penyesuaian halus pada ucapan yang ditranskripsi, dapat melampaui metode semi-supervised terbaik sambil tetap lebih sederhana secara konseptual. wav2vec 2.0 memasker input ucapan di ruang laten dan menyelesaikan tugas kontras yang didefinisikan atas kuantisasi dari representasi laten yang dipelajari secara bersama-sama. Eksperimen menggunakan semua data berlabel dari Librispeech mencapai 1,8/3,3 WER pada set uji bersih/lainnya. Ketika jumlah data berlabel diturunkan menjadi satu jam, wav2vec 2.0 melampaui state of the art sebelumnya pada subset 100 jam sambil menggunakan 100 kali lebih sedikit data berlabel. Menggunakan hanya sepuluh menit data berlabel dan pra-pelatihan pada 53k jam data tanpa label masih mencapai 4,8/8,2 WER. Hal ini menunjukkan kelayakan pengenalan ucapan dengan jumlah data berlabel yang terbatas.*

Model ini disumbangkan oleh [patrickvonplaten](https://huggingface.co/patrickvonplaten).

Catatan: Meta (FAIR) merilis versi baru dari [Wav2Vec2-BERT 2.0](./wav2vec2-bert) - model ini telah dipretrain pada 4,5 juta jam audio. Kami sangat merekomendasikannya untuk tugas fine-tuning, misalnya sesuai dengan [panduan ini](https://huggingface.co/blog/fine-tune-w2v2-bert).

> [!TIP]
> Setel `use_kernels=True` di [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengganti lapisan yang didukung dengan kernel yang dioptimalkan dari Hub. Lihat [Memuat kernel](../kernel_doc/loading_kernels) untuk mempelajari lebih lanjut.

## Tips penggunaan

- Wav2Vec2 adalah model ucapan yang menerima array float yang sesuai dengan gelombang mentah dari sinyal ucapan.
- Model Wav2Vec2 dilatih menggunakan connectionist temporal classification (CTC) sehingga output model harus didekode menggunakan [Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).

## Menggunakan Flash Attention 2

Flash Attention 2 adalah versi yang lebih cepat dan dioptimalkan dari model tersebut.

### Instalasi

Pertama, periksa apakah perangkat keras Anda kompatibel dengan Flash Attention 2. Daftar perangkat keras yang kompatibel terbaru dapat ditemukan di [dokumentasi resmi](https://github.com/Dao-AILab/flash-attention#installation-and-features).

Selanjutnya, [instal](https://github.com/Dao-AILab/flash-attention#installation-and-features) versi terbaru Flash Attention 2:

```bash
pip install -U flash-attn --no-build-isolation
```

### Penggunaan

Untuk memuat model menggunakan Flash Attention 2, kita dapat melewatkan argumen `attn_implementation="flash_attention_2"` ke [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained). Kita juga akan memuat model dalam presisi setengah (misalnya `torch.float16`), karena hal ini menghasilkan degradasi kualitas audio yang hampir tidak ada tetapi penggunaan memori yang jauh lebih rendah dan inferensi yang lebih cepat:

```python
from transformers import Wav2Vec2Model

model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...
```

### Percepatan yang diharapkan

Berikut adalah diagram percepatan yang diharapkan, membandingkan waktu inferensi murni antara implementasi native di transformers untuk model `facebook/wav2vec2-large-960h-lv60-self` dan versi flash-attention-2 serta sdpa (scale-dot-product-attention). Kami menampilkan rata-rata percepatan yang diperoleh pada split validasi `librispeech_asr` `clean`:

## Sumber daya

Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan Wav2Vec2. Jika Anda tertarik untuk mengirimkan sumber agar disertakan di sini, silakan buka Pull Request dan kami akan meninjaunya! Sumber tersebut sebaiknya mendemonstrasikan sesuatu yang baru, bukan menduplikasi sumber yang sudah ada.

- Notebook tentang cara [memanfaatkan model Wav2Vec2 yang telah dilatih sebelumnya untuk klasifikasi emosi](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb) ini.
- [Panduan tugas klasifikasi audio](../tasks/audio_classification)

- Sebuah artikel blog tentang [meningkatkan Wav2Vec2 dengan n-gram di 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- Sebuah artikel blog tentang cara [mengatur ulang Wav2Vec2 untuk ASR bahasa Inggris dengan 🤗 Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- Sebuah artikel blog tentang [finetuning XLS-R untuk Multi-Lingual ASR dengan 🤗 Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- Notebook tentang cara [membuat caption YouTube dari video apa pun dengan mentranskripsi audio menggunakan Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) didukung oleh notebook tentang [bagaimana cara finetune model pengenalan ucapan dalam bahasa Inggris](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb), dan [bagaimana cara finetune model pengenalan ucapan dalam bahasa apa pun](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).
- [Panduan tugas pengenalan ucapan otomatis](../tasks/asr)

🚀 Deploy

- Sebuah artikel blog tentang cara mendeploy Wav2Vec2 untuk [Automatic Speech Recognition dengan Transformers & Amazon SageMaker dari Hugging Face](https://www.philschmid.de/automatic-speech-recognition-sagemaker).

## Wav2Vec2Config[[transformers.Wav2Vec2Config]]

#### transformers.Wav2Vec2Config[[transformers.Wav2Vec2Config]]

```python
transformers.Wav2Vec2Config(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, vocab_size: int | None = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, feat_extract_norm: str = 'group', feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, do_stable_layer_norm: bool = False, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500), tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1), tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1), xvector_output_dim: int = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 3, output_hidden_size: int | None = None, adapter_attn_dim: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/configuration_wav2vec2.py#L27)

**Parameter:**

vocab_size (`int`, *opsional*, defaultnya `32`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi.

num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

hidden_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio dropout untuk probabilitas perhatian.

feat_proj_dropout (`float`, *opsional*, default 0.0) : Probabilitas dropout untuk output dari feature encoder.

feat_quantizer_dropout (`float`, *opsional*, default 0.0) : Probabilitas dropout untuk output dari feature encoder yang digunakan oleh quantizer.

final_dropout (`float`, *opsional*, default 0.1) : Probabilitas dropout untuk lapisan proyeksi akhir dari [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas LayerDrop. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut.

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

layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

feat_extract_norm (`str`, *opsional*, defaultnya `"group"`) : Normalisasi yang diterapkan pada lapisan konvolusional 1D di feature encoder. Salah satu dari `"group"` untuk normalisasi grup hanya pada lapisan konvolusional 1D pertama atau `"layer"` untuk normalisasi lapisan pada semua lapisan konvolusional 1D.

feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.

conv_dim (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(512, 512, 512, 512, 512, 512, 512)`) : Tuple dari bilangan bulat yang mendefinisikan jumlah saluran input dan output dari setiap lapisan konvolusional 1D dalam feature encoder. Panjang dari *conv_dim* mendefinisikan jumlah lapisan konvolusional 1D.

conv_stride (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(5, 2, 2, 2, 2, 2, 2)`) : Tuple dari bilangan bulat yang mendefinisikan stride dari setiap lapisan konvolusional 1D dalam feature encoder. Panjang dari *conv_stride* mendefinisikan jumlah lapisan konvolusional dan harus sesuai dengan panjang dari *conv_dim*.

conv_kernel (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(10, 3, 3, 3, 3, 3, 3)`) : Tuple dari bilangan bulat yang mendefinisikan ukuran kernel dari setiap lapisan konvolusional 1D dalam encoder fitur. Panjang dari *conv_kernel* mendefinisikan jumlah lapisan konvolusional dan harus sesuai dengan panjang dari *conv_dim*.

conv_bias (`bool`, *opsional*, defaultnya `False`) : Apakah lapisan konvolusional 1D memiliki bias.

num_conv_pos_embeddings (`int`, *opsional*, default 128) : Jumlah embedding posisi konvolusional. Menentukan ukuran kernel dari lapisan embedding posisi konvolusional 1D.

num_conv_pos_embedding_groups (`int`, *opsional*, default 16) : Jumlah grup dari lapisan embedding posisional konvolusional 1D.

do_stable_layer_norm (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan arsitektur layer norm *stabil* dari encoder Transformer. `do_stable_layer_norm is True` berarti menerapkan layer norm sebelum lapisan attention, sedangkan `do_stable_layer_norm is False` berarti menerapkan layer norm setelah lapisan attention.

apply_spec_augment (`bool`, *opsional*, defaultnya `True`) : Apakah akan menerapkan augmentasi data *SpecAugment* pada output dari feature encoder. Untuk referensi, lihat [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779).

mask_time_prob (`float`, *opsional*, default 0.05) : Persentase (antara 0 dan 1) dari semua vektor fitur sepanjang sumbu waktu yang akan dimasker. Prosedur masking menghasilkan ''mask_time_prob*len(time_axis)/mask_time_length'' mask independen di sepanjang sumbu tersebut. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_time_prob* seharusnya `prob_vector_start*mask_time_length`. Perhatikan bahwa tumpang tindih dapat mengurangi persentase vektor yang sebenarnya dimasker. Ini hanya relevan jika `apply_spec_augment is True`.

mask_time_length (`int`, *opsional*, default 10) : Panjang rentang vektor sepanjang sumbu waktu.

mask_time_min_masks (`int`, *opsional*, default 2), : Jumlah minimum masker dengan panjang `mask_feature_length` yang dihasilkan sepanjang sumbu waktu, setiap langkah waktu, terlepas dari `mask_feature_prob`. Hanya relevan jika ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks''

mask_feature_prob (`float`, *opsional*, default 0.0) : Persentase (antara 0 dan 1) dari semua vektor fitur di sepanjang sumbu fitur yang akan dimasker. Prosedur masking menghasilkan ''mask_feature_prob*len(feature_axis)/mask_time_length'' mask independen di sepanjang sumbu tersebut. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_feature_prob* seharusnya `prob_vector_start*mask_feature_length`. Perhatikan bahwa tumpang tindih dapat mengurangi persentase vektor yang sebenarnya dimasker. Ini hanya relevan jika `apply_spec_augment is True`.

mask_feature_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Persentase (antara 0 dan 1) dari semua vektor fitur di sepanjang sumbu fitur yang akan dimasker. Prosedur masking menghasilkan `mask_feature_prob*len(feature_axis)/mask_time_length` mask independen di sepanjang sumbu. Jika beralasan dari probabilitas setiap vektor fitur untuk dipilih sebagai awal dari rentang vektor yang akan dimasker, *mask_feature_prob* seharusnya `prob_vector_start*mask_feature_length`. Perhatikan bahwa tumpang tindih dapat mengurangi persentase vektor yang sebenarnya dimasker. Ini hanya relevan jika `apply_spec_augment` adalah `True`.

mask_feature_length (`int`, *opsional*, default 10) : Panjang rentang vektor di sepanjang sumbu fitur.

mask_feature_min_masks (`int`, *opsional*, default 0), : Jumlah minimum masker dengan panjang `mask_feature_length` yang dihasilkan di sepanjang sumbu fitur, setiap langkah waktu, terlepas dari `mask_feature_prob`. Hanya relevan jika ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''

num_codevectors_per_group (`int`, *opsional*, default 320) : Jumlah entri dalam setiap codebook kuantisasi (grup).

num_codevectors_per_group (`int`, *opsional*, default 320) : Jumlah entri dalam setiap codebook kuantisasi (grup).

num_codevector_groups (`int`, *opsional*, defaultnya 2) : Jumlah grup codevector untuk kuantisasi codevector produk.

contrastive_logits_temperature (`float`, *opsional*, default 0.1) : Suhu *kappa* dalam kerugian kontras.

num_negatives (`int`, *opsional*, default 100) : Jumlah sampel negatif untuk kerugian kontras (contrastive loss).

codevector_dim (`int`, *opsional*, default 256) : Dimensi dari vektor fitur yang dikuantisasi.

proj_codevector_dim (`int`, *opsional*, default 256) : Dimensi dari proyeksi akhir dari fitur kuantisasi dan fitur transformer.

diversity_loss_weight (`int`, *opsional*, default 0.1) : Bobot komponen kerugian keragaman kodebook.

ctc_loss_reduction (`str`, *opsional*, defaultnya `"sum"`) : Menentukan reduksi yang diterapkan pada output dari `torch.nn.CTCLoss`. Hanya relevan saat melatih instance dari [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

ctc_zero_infinity (`bool`, *opsional*, defaultnya `False`) : Apakah akan menolkan kerugian tak hingga dan gradien terkait dari `torch.nn.CTCLoss`. Kerugian tak hingga terutama terjadi ketika input terlalu pendek untuk diselaraskan dengan target. Hanya relevan saat melatih instance dari [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

use_weighted_layer_sum (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan rata-rata berbobot dari output lapisan dengan bobot yang dipelajari. Hanya relevan saat menggunakan instance dari [Wav2Vec2ForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification).

classifier_proj_size (`int`, *opsional*, default 256) : Dimensi proyeksi sebelum token mean-pooling untuk klasifikasi.

tdnn_dim (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(512, 512, 512, 512, 1500)`) : Tuple dari bilangan bulat yang mendefinisikan jumlah kanal output dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang dari *tdnn_dim* mendefinisikan jumlah lapisan *TDNN*.

tdnn_kernel (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(5, 3, 3, 1, 1)`) : Tuple dari bilangan bulat yang mendefinisikan ukuran kernel dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang *tdnn_kernel* harus sesuai dengan panjang *tdnn_dim*.

tdnn_dilation (`tuple[int]` atau `list[int]`, *opsional*, defaultnya `(1, 2, 3, 1, 1)`) : Tuple bilangan bulat yang mendefinisikan faktor dilatasi dari setiap lapisan konvolusional 1D dalam modul *TDNN* dari model *XVector*. Panjang *tdnn_dilation* harus sesuai dengan panjang *tdnn_dim*.

xvector_output_dim (`int`, *opsional*, default 512) : Dimensi dari vektor embedding *XVector*.

pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*, defaultnya `1`) : Token id yang digunakan untuk awal-stream dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `2`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

add_adapter (`bool`, *opsional*, defaultnya `False`) : Apakah jaringan konvolusional harus ditumpuk di atas Wav2Vec2 Encoder. Dapat sangat berguna untuk memulai dengan hangat (warm-starting) Wav2Vec2 untuk model SpeechEncoderDecoder.

adapter_kernel_size (`int`, *opsional*, default 3) : Ukuran kernel dari lapisan konvolusional dalam jaringan adapter. Hanya relevan jika `add_adapter is True`.

adapter_stride (`int`, *opsional*, defaultnya 2) : Stride dari lapisan konvolusional dalam jaringan adapter. Hanya relevan jika `add_adapter is True`.

num_adapter_layers (`int`, *opsional*, default 3) : Jumlah lapisan konvolusional yang harus digunakan dalam jaringan adapter. Hanya relevan jika `add_adapter is True`.

output_hidden_size (`int`, *opsional*) : Dimensi dari lapisan output encoder. Jika tidak didefinisikan, ini secara default menjadi *hidden-size*. Hanya relevan jika `add_adapter is True`.

adapter_attn_dim (`int`, *opsional*) : Dimensi dari bobot adapter perhatian yang akan digunakan di setiap blok perhatian. Contoh model yang menggunakan adapter perhatian adalah [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Wav2Vec2Model. Kelas ini digunakan untuk membuat instans model Wav2Vec2 sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [facebook/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h)

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 Wav2Vec2Config, Wav2Vec2Model

>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)

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

## Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

#### transformers.Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

```python
transformers.Wav2Vec2CTCTokenizer(vocab_file, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', word_delimiter_token = '|', replace_word_delimiter_char = ' ', do_lower_case = False, target_lang = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L101)

**Parameter:**

vocab_file (`str`) : File yang berisi kosakata.

bos_token (`str`, *opsional*, defaultnya `"<s>"`) : Token awal kalimat.

eos_token (`str`, *opsional*, defaultnya `"</s>"`) : Token akhir kalimat.

unk_token (`str`, *opsional*, defaultnya `"<unk>"`) : Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini.

pad_token (`str`, *opsional*, defaultnya `"<pad>"`) : Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda.

word_delimiter_token (`str`, *opsional*, defaultnya `"|"`) : Token yang digunakan untuk menentukan akhir dari sebuah kata.

do_lower_case (`bool`, *opsional*, defaultnya `False`) : Apakah menerima input huruf kecil dan mengubah output menjadi huruf kecil saat decoding.

target_lang (`str`, *opsional*) : Bahasa target yang harus diset secara default oleh tokenizer. `target_lang` harus didefinisikan untuk kosakata bersarang multibahasa seperti [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke [PreTrainedTokenizer](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.PythonBackend)

Membangun tokenizer Wav2Vec2CTC.

Tokenizer ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.PythonBackend) yang berisi beberapa metode utama. Pengguna harus merujuk ke kelas induk untuk informasi lebih lanjut mengenai metode tersebut.

#### __call__[[transformers.Wav2Vec2CTCTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2448)

**Parameter:**

text (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

tokenizer_kwargs (`dict[str, Any]`, *opsional*) : kwargs tambahan untuk diteruskan ke tokenizer. Nilai-nilai ini akan digabungkan dengan parameter eksplisit dan kwargs lainnya, dengan parameter eksplisit memiliki prioritas lebih tinggi.

add_special_tokens (`bool`, *opsional*, default `True`) : Menentukan apakah token khusus akan ditambahkan saat meng-encode urutan. Hal ini akan menggunakan fungsi `PretrainedTokenizerBase.build_inputs_with_special_tokens` yang mendasarinya, yang mendefinisikan token apa saja yang secara otomatis ditambahkan ke input ids. Ini berguna jika Anda ingin menambahkan token `bos` atau `eos` secara otomatis.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad 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`, `str` atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

stride (`int`, *opsional*, default 0) : Jika diatur ke sebuah angka bersamaan dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan memuat beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.

is_split_into_words (`bool`, *opsional*, default `False`) : Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata-kata). Jika disetel ke `True`, tokenizer mengasumsikan input sudah dipecah menjadi kata-kata (misalnya, dengan memisahkannya berdasarkan spasi) yang kemudian akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, sekuens akan di-*pad* menjadi kelipatan dari nilai yang diberikan. Memerlukan `padding` untuk diaktifkan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta).

padding_side (`str`, *opsional*) : Sisi tempat model harus menerapkan padding. Harus dipilih dari ['right', 'left']. Nilai default diambil dari atribut kelas dengan nama yang sama.

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 bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

return_token_type_ids (`bool`, *opsional*) : Apakah akan mengembalikan token type ID. Jika dibiarkan pada nilai default, akan mengembalikan token type ID sesuai default tokenizer tertentu, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu token type ID?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, attention mask akan dikembalikan sesuai dengan default tokenizer yang bersangkutan, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu attention mask?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan urutan token yang meluap. Jika sepasang urutan id input (atau batch dari pasangan) diberikan dengan `truncation_strategy = longest_first` atau `True`, error akan dilemparkan alih-alih mengembalikan token yang meluap.

return_special_tokens_mask (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan informasi mask token khusus.

return_offsets_mapping (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan `(char_start, char_end)` untuk setiap token. Ini hanya tersedia pada fast tokenizer yang mewarisi dari [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend); jika menggunakan tokenizer Python, metode ini akan melempar `NotImplementedError`.

return_length  (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan panjang dari input yang dikodekan.

verbose (`bool`, *opsional*, default `True`) : Apakah akan mencetak informasi dan peringatan yang lebih banyak.

- ****kwargs** : diteruskan ke metode `self.tokenize()`

**Mengembalikan:** [BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding)

[BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding) dengan bidang berikut:

- **input_ids** -- Daftar id token yang akan diberikan ke model.

  [Apa itu input ID?](../glossary#input-ids)

- **token_type_ids** -- Daftar token type id yang akan diberikan ke model (ketika `return_token_type_ids=True` atau jika *"token_type_ids"* ada di `self.model_input_names`).

  [Apa itu token type ID?](../glossary#token-type-ids)

- **attention_mask** -- Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika `return_attention_mask=True` atau jika *"attention_mask"* ada di `self.model_input_names`).

  [Apa itu attention mask?](../glossary#attention-mask)

- **overflowing_tokens** -- Daftar sekuens token yang meluap (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Jumlah token yang dipangkas (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Daftar angka 0 dan 1, di mana 1 menandakan token khusus yang ditambahkan dan 0 menandakan token urutan reguler (ketika `add_special_tokens=True` dan `return_special_tokens_mask=True`).
- **length** -- Panjang dari input (ketika `return_length=True`)

Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa urutan, atau satu atau beberapa pasangan urutan, untuk model.

#### save_vocabulary[[transformers.Wav2Vec2CTCTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L643)

#### decode[[transformers.Wav2Vec2CTCTokenizer.decode]]

```python
decode(token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L538)

**Parameter:**

token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Daftar id input yang telah ditokenisasi. Dapat diperoleh menggunakan metode `__call__`.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi tokenisasi atau tidak.

output_char_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset karakter atau tidak. Offset karakter dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari karakter yang ditranskripsi. Silakan lihat contoh di bawah ini untuk lebih memahami cara memanfaatkan `output_char_offsets`.

output_word_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset kata atau tidak. Offset kata dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari kata-kata yang ditranskripsi. Silakan lihat contoh di bawah ini untuk lebih memahami cara memanfaatkan `output_word_offsets`.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode decode spesifik model yang mendasarinya.

**Mengembalikan:** `str` atau `Wav2Vec2CTCTokenizerOutput`

Daftar kalimat yang telah didekodekan. Akan berupa `Wav2Vec2CTCTokenizerOutput` ketika `output_char_offsets == True` atau `output_word_offsets == True`.

Mengonversi urutan id dalam string, menggunakan tokenizer dan kosakata dengan opsi untuk menghapus token khusus dan merapikan spasi tokenisasi.

Mirip dengan melakukan `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

Contoh:

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]
```

#### batch_decode[[transformers.Wav2Vec2CTCTokenizer.batch_decode]]

```python
batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L468)

**Parameter:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Daftar id input yang telah ditokenisasi. Dapat diperoleh menggunakan metode `__call__`.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi tokenisasi atau tidak.

output_char_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset karakter atau tidak. Offset karakter dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari karakter yang ditranskripsi.    Silakan lihat Contoh [decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) untuk lebih memahami cara memanfaatkan `output_char_offsets`. [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) bekerja dengan cara yang sama untuk output yang di-batch.

output_word_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset kata atau tidak. Offset kata dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari kata-kata yang ditranskripsi.    Silakan lihat Contoh [decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) untuk lebih memahami cara memanfaatkan `output_word_offsets`. [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) bekerja dengan cara yang sama untuk output yang di-batch.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode decode spesifik model yang mendasarinya.

**Mengembalikan:** `list[str]` atau `Wav2Vec2CTCTokenizerOutput`

Daftar kalimat yang telah didekodekan. Akan berupa `Wav2Vec2CTCTokenizerOutput` ketika `output_char_offsets == True` atau `output_word_offsets == True`.

Konversi daftar dari daftar id token menjadi daftar string dengan memanggil decode.

#### set_target_lang[[transformers.Wav2Vec2CTCTokenizer.set_target_lang]]

```python
set_target_lang(target_lang: str)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L184)

Atur bahasa target dari kamus multi-bahasa bersarang

## Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

#### transformers.Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

```python
transformers.Wav2Vec2FeatureExtractor(feature_size = 1, sampling_rate = 16000, padding_value = 0.0, return_attention_mask = False, do_normalize = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L28)

**Parameter:**

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

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

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

do_normalize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi input menjadi nol-rata-rata dan varians-satuan. Normalisasi dapat membantu meningkatkan kinerja secara signifikan untuk beberapa model, *misalnya*, [wav2vec2-lv60](https://huggingface.co/models?search=lv60).

return_attention_mask (`bool`, *opsional*, defaultnya `False`) : Apakah [__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) harus mengembalikan `attention_mask`.    Model Wav2Vec2 yang telah mengatur `config.feat_extract_norm == "group"`, seperti [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **tidak** dilatih menggunakan `attention_mask`. Untuk model semacam itu, `input_values` cukup di-pad dengan 0 dan tidak perlu meneruskan `attention_mask`.  Untuk model Wav2Vec2 yang telah mengatur `config.feat_extract_norm == "layer"`, seperti [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` harus diteruskan untuk inferensi batched.

Membangun ekstraktor fitur Wav2Vec2.

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.Wav2Vec2FeatureExtractor.__call__]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L99)

**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.

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

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

truncation (`bool`) : 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_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)    Model Wav2Vec2 yang telah mengatur `config.feat_extract_norm == "group"`, seperti [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **tidak** dilatih menggunakan `attention_mask`. Untuk model semacam itu, `input_values` cukup di-pad dengan 0 dan tidak perlu meneruskan `attention_mask`.  Untuk model Wav2Vec2 yang telah mengatur `config.feat_extract_norm == "layer"`, seperti [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` harus diteruskan untuk inferensi batched.

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 bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

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.

padding_value (`float`, *opsional*, default 0.0) --

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

## Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

#### transformers.Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

```python
transformers.Wav2Vec2Processor(feature_extractor, tokenizer)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/processing_wav2vec2.py#L25)

**Parameter:**

feature_extractor (`Wav2Vec2FeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

tokenizer (`Wav2Vec2CTCTokenizer`) : Tokenizer adalah input yang wajib.

Membangun Wav2Vec2Processor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[Wav2Vec2Processor](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor) menyediakan semua fungsionalitas dari [Wav2Vec2FeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) dan [Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer). Lihat [~Wav2Vec2FeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) dan [~Wav2Vec2CTCTokenizer](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.Wav2Vec2Processor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | None = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

**Parameter:**

audio (`Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]]`, *opsional*) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

text (`Union[str, list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string pretokenized). Jika Anda memasukkan input pretokenized, atur `is_split_into_words=True` untuk menghindari ambiguitas dengan input batched.

return_mm_token_type_ids (`bool`, *kwargs*) : Apakah akan mengembalikan id tipe token multimodal yang menunjukkan posisi token placeholder multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Apakah akan mengembalikan offset karakter untuk setiap placeholder multimodal dan pengantinya.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:**

Metode ini mengembalikan hasil dari setiap metode `call`. Jika keduanya digunakan, outputnya adalah kamus yang berisi hasil dari keduanya.

#### pad[[transformers.Wav2Vec2Processor.pad]]

```python
pad(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/processing_wav2vec2.py#L61)

**Parameter:**

input_features : Ketika argumen pertama adalah kamus yang berisi batch tensor, atau argumen `input_features` ada, maka diteruskan ke [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

labels : Ketika argumen `label` hadir, argumen tersebut diteruskan ke [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).

**Mengembalikan:**

Metode ini mengembalikan hasil dari setiap metode `pad`. Jika keduanya digunakan, outputnya adalah kamus yang berisi hasil dari keduanya.

Metode ini beroperasi pada batch fitur yang diekstraksi dan/atau teks yang ditokenisasi. Metode ini meneruskan semua argumen ke [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) dan/atau [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) tergantung pada modalitas input, lalu mengembalikan output dari keduanya. Jika kedua modalitas diberikan, [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) dan [PreTrainedTokenizer.pad()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) akan dipanggil.

#### from_pretrained[[transformers.Wav2Vec2Processor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1799)

**Parameter:**

pretrained_model_name_or_path (`str` atau `os.PathLike`) : Ini bisa berupa:  - string, *model id* dari feature_extractor pretrained yang dihosting di dalam model repo di huggingface.co. - path ke *directory* yang berisi file feature extractor yang disimpan menggunakan metode [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), misalnya `./my_model_directory/`. - path ke file JSON feature extractor yang disimpan, *file*, misalnya `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) dan `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instansiasi prosesor yang terkait dengan model pretrained.

Metode kelas ini hanya memanggil metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) dari feature extractor, [ImageProcessingMixin](/docs/transformers/v5.23.0/id/internal/image_processing_utils#transformers.ImageProcessingMixin) dari image processor, dan `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` dari tokenizer. Silakan merujuk ke docstring dari metode-metode di atas untuk informasi lebih lanjut.

#### save_pretrained[[transformers.Wav2Vec2Processor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L1182)

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori tempat file JSON feature extractor dan file tokenizer akan disimpan (direktori akan dibuat jika belum ada).

push_to_hub (`bool`, *opsional*, default `False`) : Apakah model akan didorong ke Hugging Face model hub setelah disimpan. Anda dapat menentukan repositori tujuan dengan `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Menyimpan atribut prosesor ini (feature extractor, tokenizer...) ke dalam direktori yang ditentukan sehingga dapat dimuat ulang menggunakan metode [from_pretrained()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Metode kelas ini hanya memanggil [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) dan [save_pretrained()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Silakan merujuk ke docstring dari metode di atas untuk informasi lebih lanjut.

#### batch_decode[[transformers.Wav2Vec2Processor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2054)

Metode ini meneruskan semua argumennya ke [batch_decode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) dari PreTrainedTokenizer. Silakan lihat docstring dari metode ini untuk informasi lebih lanjut.

#### decode[[transformers.Wav2Vec2Processor.decode]]

```python
decode(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2063)

Metode ini meneruskan semua argumennya ke [decode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) dari PreTrainedTokenizer. Silakan lihat docstring dari metode ini untuk informasi lebih lanjut.

## Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

> [!WARNING]
> [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) dan decoding model bahasa n-gram dengan pyctcdecode + kenlm telah didepresiasi dan akan dihapus di Transformers v6. Keduanya memerlukan pyctcdecode dan kenlm, yang tidak lagi diinstal bersama `transformers[audio]`. Untuk mempertahankan decoding model bahasa, panggil pyctcdecode secara langsung, lihat [Migrating to pyctcdecode](#migrating-to-pyctcdecode).

#### transformers.Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

```python
transformers.Wav2Vec2ProcessorWithLM(feature_extractor: FeatureExtractionMixin, tokenizer: PreTrainedTokenizerBase, decoder: BeamSearchDecoderCTC)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L70)

**Parameter:**

feature_extractor (`feature_extractor_class`) : Feature extractor adalah input yang wajib.

tokenizer (`tokenizer_class`) : Tokenizer adalah input yang wajib.

decoder (`BeamSearchDecoderCTC`) : Sebuah instance dari `pyctcdecode.BeamSearchDecoderCTC`. Decoder merupakan input yang wajib.

Membangun Wav2Vec2ProcessorWithLM yang membungkus feature extractor dan tokenizer menjadi satu processor.

[Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) menyediakan semua fungsionalitas dari `feature_extractor_class` dan `tokenizer_class`. Lihat `~feature_extractor_class` dan `~tokenizer_class` untuk informasi lebih lanjut.

#### __call__[[transformers.Wav2Vec2ProcessorWithLM.__call__]]

```python
__call__(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L219)

**Parameter:**

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

#### pad[[transformers.Wav2Vec2ProcessorWithLM.pad]]

```python
pad(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L244)

Saat digunakan dalam mode normal, metode ini meneruskan semua argumennya ke `~FeatureExtractionMixin.pad` dari feature extractor dan mengembalikan output-nya. Jika digunakan dalam konteks `~Wav2Vec2ProcessorWithLM.as_target_processor`, metode ini meneruskan semua argumennya ke [pad()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) dari Wav2Vec2CTCTokenizer. Silakan merujuk ke docstring dari dua metode di atas untuk informasi lebih lanjut.

#### from_pretrained[[transformers.Wav2Vec2ProcessorWithLM.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L112)

**Parameter:**

pretrained_model_name_or_path (`str` atau `os.PathLike`) : Ini bisa berupa:  - string, *model id* dari feature_extractor pretrained yang dihosting di dalam model repo di huggingface.co. - path ke *directory* yang berisi file feature extractor yang disimpan menggunakan metode [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), misalnya `./my_model_directory/`. - path ke file JSON feature extractor yang disimpan, *file*, misalnya `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke [SequenceFeatureExtractor](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) dan [PreTrainedTokenizer](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.PythonBackend)

Instansiasi [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) dari prosesor Wav2Vec2 yang telah dilatih sebelumnya.

Metode kelas ini hanya memanggil [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) dari feature extractor, [from_pretrained()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained) dari Wav2Vec2CTCTokenizer, dan `pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub`.

Silakan merujuk pada docstring dari metode-metode di atas untuk informasi lebih lanjut.

#### save_pretrained[[transformers.Wav2Vec2ProcessorWithLM.save_pretrained]]

```python
save_pretrained(save_directory)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L108)

#### batch_decode[[transformers.Wav2Vec2ProcessorWithLM.batch_decode]]

```python
batch_decode(logits: ndarray, pool: multiprocessing.pool.Pool | None = None, num_processes: int | None = None, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L271)

**Parameter:**

logits (`np.ndarray`) : Vektor output logits dari model yang mewakili log probabilitas untuk setiap token.

pool (`multiprocessing.Pool`, *opsional*) : Pool yang dikelola pengguna secara opsional. Jika tidak diset, pool akan dibuat dan ditutup secara otomatis. Pool harus diinstansiasi *setelah* `Wav2Vec2ProcessorWithLM`. Jika tidak, LM tidak akan tersedia untuk sub-proses pool. Saat ini, hanya pool yang dibuat dengan konteks 'fork' yang dapat digunakan. Jika pool 'spawn' diberikan, pool tersebut akan diabaikan dan decoding sekuensial akan digunakan sebagai gantinya.

num_processes (`int`, *opsional*) : Jika `pool` tidak diatur, jumlah proses di mana fungsi harus diparalelkan. Secara default, menggunakan jumlah CPU yang tersedia.

beam_width (`int`, *opsional*) : Jumlah maksimum beam pada setiap langkah dalam decoding. Secara default menggunakan DEFAULT_BEAM_WIDTH dari pyctcdecode.

beam_prune_logp (`int`, *opsional*) : Beam yang jauh lebih buruk dari beam terbaik akan dipangkas. Nilai defaultnya adalah DEFAULT_PRUNE_LOGP dari pyctcdecode.

token_min_logp (`int`, *opsional*) : Token di bawah logp ini dilewati kecuali jika merupakan argmax dari frame. Secara default menggunakan DEFAULT_MIN_TOKEN_LOGP dari pyctcdecode.

hotwords (`list[str]`, *opsional*) : Daftar kata dengan kepentingan tambahan, dapat berupa OOV untuk LM

hotword_weight (`int`, *opsional*) : Faktor bobot untuk kepentingan hotword. Bawaan adalah DEFAULT_HOTWORD_WEIGHT dari pyctcdecode.

alpha (`float`, *opsional*) : Bobot untuk model bahasa selama shallow fusion

beta (`float`, *opsional*) : Bobot untuk penyesuaian skor panjang selama penilaian

unk_score_offset (`float`, *opsional*) : Jumlah offset skor log untuk token yang tidak dikenal

lm_score_boundary (`bool`, *opsional*) : Apakah kenlm harus menghormati batas saat melakukan penilaian

output_word_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset kata atau tidak. Offset kata dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari kata-kata yang ditranskripsi.

n_best (`int`, *opsional*, defaultnya `1`) : Jumlah hipotesis terbaik yang akan dikembalikan. Jika `n_best` lebih besar dari 1, `text` yang dikembalikan akan berupa daftar dari daftar string, `logit_score` akan berupa daftar dari daftar float, dan `lm_score` akan berupa daftar dari daftar float, di mana panjang daftar luar akan sesuai dengan ukuran batch dan panjang daftar dalam akan sesuai dengan jumlah hipotesis yang dikembalikan. Nilainya harus >= 1. Silakan lihat Contoh [decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) untuk lebih memahami cara memanfaatkan `output_word_offsets`. [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) bekerja dengan cara yang sama untuk output yang di-batch.

**Mengembalikan:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Batch decode output logits menjadi transkripsi audio dengan dukungan model bahasa.

Fungsi ini memanfaatkan multiprocessing dari Python. Saat ini, multiprocessing hanya tersedia pada sistem Unix (lihat [masalah](https://github.com/kensho-technologies/pyctcdecode/issues/65) ini).

Jika Anda melakukan decoding beberapa batch, pertimbangkan untuk membuat `Pool` dan meneruskannya ke `batch_decode`. Jika tidak, `batch_decode` akan sangat lambat karena akan membuat `Pool` baru untuk setiap pemanggilan. Lihat contoh penggunaan di bawah.

Contoh: Lihat [Mendekoding beberapa audio](#decoding-multiple-audios).

#### decode[[transformers.Wav2Vec2ProcessorWithLM.decode]]

```python
decode(logits: ndarray, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L456)

**Parameter:**

logits (`np.ndarray`) : Vektor output logits dari model yang mewakili log probabilitas untuk setiap token.

beam_width (`int`, *opsional*) : Jumlah maksimum beam pada setiap langkah dalam decoding. Secara default menggunakan DEFAULT_BEAM_WIDTH dari pyctcdecode.

beam_prune_logp (`int`, *opsional*) : Ambang batas untuk memangkas beam dengan log-probs kurang dari best_beam_logp + beam_prune_logp. Nilainya harus <= 0. Secara default menggunakan DEFAULT_PRUNE_LOGP dari pyctcdecode.

token_min_logp (`int`, *opsional*) : Token dengan log-probs di bawah token_min_logp dilewati kecuali mereka memiliki log-prob maksimum untuk sebuah ucapan. Secara default menggunakan DEFAULT_MIN_TOKEN_LOGP dari pyctcdecode.

hotwords (`list[str]`, *opsional*) : Daftar kata dengan kepentingan tambahan yang mungkin tidak ada dalam kosakata LM, misalnya ["huggingface"]

hotword_weight (`int`, *opsional*) : Pengali bobot yang meningkatkan skor hotword. Bawaan adalah DEFAULT_HOTWORD_WEIGHT dari pyctcdecode.

alpha (`float`, *opsional*) : Bobot untuk model bahasa selama shallow fusion

beta (`float`, *opsional*) : Bobot untuk penyesuaian skor panjang selama penilaian

unk_score_offset (`float`, *opsional*) : Jumlah offset skor log untuk token yang tidak dikenal

lm_score_boundary (`bool`, *opsional*) : Apakah kenlm harus menghormati batas saat melakukan penilaian

output_word_offsets (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengoutputkan offset kata atau tidak. Offset kata dapat digunakan bersama dengan laju sampling dan laju downsampling model untuk menghitung stempel waktu dari kata-kata yang ditranskripsi.

n_best (`int`, *opsional*, defaultnya `1`) : Jumlah hipotesis terbaik yang akan dikembalikan. Jika `n_best` lebih besar dari 1, `text` yang dikembalikan akan berupa daftar string, `logit_score` akan berupa daftar float, dan `lm_score` akan berupa daftar float, di mana panjang daftar-daftar ini akan sesuai dengan jumlah hipotesis yang dikembalikan. Nilainya harus >= 1. Silakan lihat contoh di bawah untuk lebih memahami cara memanfaatkan `output_word_offsets`.

**Mengembalikan:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Dekode output logits menjadi transkripsi audio dengan dukungan model bahasa.

Contoh:

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
...     logits = model(input_values).logits[0].cpu().numpy()

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
```

### Mendekode beberapa audio

> [!WARNING]
> Contoh ini menggunakan [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) yang sudah tidak didukung lagi. Untuk kode baru, berikan `multiprocessing.Pool` ke `decode_beams_batch` dari pyctcdecode sebagai gantinya, lihat [Migrasi ke pyctcdecode](#migrating-to-pyctcdecode).

Jika Anda berencana untuk mendekode beberapa batch audio, sebaiknya pertimbangkan untuk menggunakan [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) dan meneruskan `multiprocessing.Pool` yang sudah diinstansiasi. Jika tidak, kinerja [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) akan lebih lambat daripada memanggil [decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) untuk setiap audio secara individual, karena secara internal menginstansiasi `Pool` baru untuk setiap pemanggilan. Lihat contoh di bawah:

```python
# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context

import datasets
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor

# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))

def map_to_array(example):
    example["speech"] = example["audio"]["array"]
    return example

# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])

def map_to_pred(batch, pool):
    inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

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

    transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
    batch["transcription"] = transcription
    return batch

# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
#       otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
    result = dataset.map(
        map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
    )

result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
```

### Migrasi ke pyctcdecode

[Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) adalah wrapper tipis di sekitar [pyctcdecode](https://github.com/kensho-technologies/pyctcdecode). Muat feature extractor dan tokenizer dengan [Wav2Vec2Processor](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor), muat language model dengan pyctcdecode, dan panggil pyctcdecode pada logits. Ini menghasilkan transkripsi yang sama dengan [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode). Ini membutuhkan [pyctcdecode](https://github.com/kensho-technologies/pyctcdecode) dan [kenlm](https://github.com/kpu/kenlm), yang tidak lagi diinstal dengan `transformers[audio]`.

```python
import torch
from pyctcdecode import BeamSearchDecoderCTC

from transformers import AutoModelForCTC, Wav2Vec2Processor

repo = "patrickvonplaten/wav2vec2-base-100h-with-lm"
model = AutoModelForCTC.from_pretrained(repo)
processor = Wav2Vec2Processor.from_pretrained(repo)  # feature extractor + tokenizer
# only download the language model and the alphabet, not the model weights
decoder = BeamSearchDecoderCTC.load_from_hf_hub(repo, allow_patterns=["language_model/*", "alphabet.json"])

inputs = processor(audio, sampling_rate=16_000, padding=True, return_tensors="pt")
with torch.no_grad():
    logits = model(**inputs).logits.cpu().numpy()

# was: processor_with_lm.batch_decode(logits, alpha=0.5, beta=1.0, beam_width=50).text

# `alpha`, `beta`, `unk_score_offset` and `lm_score_boundary` are set on the decoder (values that are not passed are kept)
decoder.reset_params(alpha=0.5, beta=1.0)

# drop the frames padded with -100, as `batch_decode` does
logits_list = [sample[(sample != -100.0).all(axis=-1)] for sample in logits]

# `beam_width`, `beam_prune_logp`, `token_min_logp`, `hotwords` and `hotword_weight` are decoding arguments
beams = decoder.decode_beams_batch(None, logits_list, beam_width=50)
transcription = [sample_beams[0][0] for sample_beams in beams]
```

- **Satu sampel**: `processor_with_lm.decode(logits[0]).text` menjadi `decoder.decode_beams(logits[0])[0][0]`.
- **Use `decode_beams` / `decode_beams_batch`**, not `decode` / `decode_batch`: the latter prune the beam history and can give different transcriptions.
- **Penyandian paralel**: berikan `multiprocessing.Pool` yang dibuat dengan konteks `fork` sebagai argumen pertama dari `decode_beams_batch`.
- **Beams** diurutkan dari yang terbaik ke yang terburuk dan juga membawa skor serta offset kata:
  - `decode_beams_batch`: `(text, word_offsets, logit_score, lm_score)`;
  - `decode_beams`: `(text, last_lm_state, word_offsets, logit_score, lm_score)`.

Untuk mendekode tanpa model bahasa, ambil token yang paling mungkin di setiap frame:

```python
transcription = processor.batch_decode(logits.argmax(-1))
```

## Output khusus Wav2Vec2[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

#### transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

```python
transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput(text: list[list[str]] | list[str] | str, logit_score: list[list[float]] | list[float] | float = None, lm_score: list[list[float]] | list[float] | float = None, word_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L46)

**Parameter:**

text (daftar `str` atau `str`) : Logit yang didekodekan dalam bentuk teks. Biasanya berupa transkripsi ucapan.

logit_score (daftar `float` atau `float`) : Skor logit total dari beam yang terkait dengan teks yang dihasilkan.

lm_score (daftar `float`) : lm_score yang digabungkan dari beam yang terkait dengan teks yang dihasilkan.

word_offsets (daftar `list[dict[str, Union[int, str]]]` atau `list[dict[str, Union[int, str]]]`) : Offset dari kata-kata yang didekodekan. Dalam kombinasi dengan laju sampling dan laju downsampling model, offset kata dapat digunakan untuk menghitung stempel waktu untuk setiap kata.

Jenis output dari [decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) dan [batch_decode()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode). Tidak didukung lagi, akan dihapus di Transformers v6.

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1299)

**Parameter:**

last_hidden_state (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) : Urutan hidden-states pada output dari lapisan terakhir model.

extract_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, conv_dim[-1])`) : Urutan vektor fitur yang diekstrak dari lapisan konvolusional terakhir model.

hidden_states (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output setiap layer ditambah output embedding awal.

attentions (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Kelas dasar untuk model yang telah dilatih dengan tujuan kerugian Wav2Vec2.

#### transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput[[transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput]]

```python
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, contrastive_loss: typing.Optional[torch.Tensor] = None, diversity_loss: typing.Optional[torch.Tensor] = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L76)

**Parameter:**

loss (`*optional*`, dikembalikan saat `sample_negative_indices` diteruskan, `torch.Tensor` dengan bentuk `(1,)`) : Total loss sebagai jumlah dari contrastive loss (L_m) dan diversity loss (L_d) sebagaimana dinyatakan dalam [paper resmi](https://huggingface.co/papers/2006.11477).

projected_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.proj_codevector_dim)`) : Hidden-states dari model yang diproyeksikan ke *config.proj_codevector_dim* yang dapat digunakan untuk memprediksi state kuantisasi terproyeksi yang dimasker.

projected_quantized_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.proj_codevector_dim)`) : Vektor fitur terekstraksi yang dikuantisasi dan diproyeksikan ke *config.proj_codevector_dim*, yang mewakili vektor target positif untuk kerugian kontras (contrastive loss).

codevector_perplexity (`torch.Tensor` dengan bentuk `(1,)`) : Perplexity dari distribusi codevector, digunakan untuk mengukur keragaman codebook.

hidden_states (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output dari setiap lapisan ditambah output embedding awal yang opsional.

attentions (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

contrastive_loss (`*optional*`, dikembalikan ketika `sample_negative_indices` diberikan, `torch.Tensor` dengan bentuk `(1,)`) : Loss kontrastif (L_m) sebagaimana dinyatakan dalam [paper resmi](https://huggingface.co/papers/2006.11477).

diversity_loss (`*optional*`, dikembalikan saat `sample_negative_indices` diteruskan, `torch.Tensor` dengan bentuk `(1,)`) : Keragaman loss (L_d) sebagaimana dinyatakan dalam [paper resmi](https://huggingface.co/papers/2006.11477).

Jenis output dari [Wav2Vec2ForPreTraining](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining), dengan potensi hidden states dan attentions.

## Wav2Vec2Model[[transformers.Wav2Vec2Model]]

#### transformers.Wav2Vec2Model[[transformers.Wav2Vec2Model]]

```python
transformers.Wav2Vec2Model(config: Wav2Vec2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1197)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 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.Wav2Vec2Model.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1271)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks untuk memasker fitur yang diekstrak untuk kerugian kontrastif. Saat dalam mode pelatihan, model belajar memprediksi fitur yang diekstrak dan dimasker dalam ruang *config.proj_codevector_dim*.

**Mengembalikan:** [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) atau `tuple(torch.Tensor)`

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

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

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **extract_features** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, conv_dim[-1])`) -- Urutan vektor fitur yang diekstrak dari lapisan konvolusional terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

#### transformers.Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

```python
transformers.Wav2Vec2ForCTC(config: Wav2Vec2Config, target_lang: str | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1525)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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.

target_lang (`str`, *opsional*) : ID bahasa dari bobot adapter. Bobot adapter disimpan dalam format adapter..safetensors atau adapter..bin. Hanya relevan saat menggunakan instance [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) dengan adapter. Menggunakan 'eng' secara default.

Model Wav2Vec2 dengan kepala `language modeling` di atasnya untuk Connectionist Temporal Classification (CTC).

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.Wav2Vec2ForCTC.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1594)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

labels (`torch.LongTensor` dengan bentuk `(batch_size, target_length)`, *opsional*) : Label untuk klasifikasi temporal koneksionis. Perhatikan bahwa `target_length` harus lebih kecil atau sama dengan panjang sekuens dari logit output. Indeks dipilih dalam `[-100, 0, ..., config.vocab_size - 1]`. Semua label yang disetel ke `-100` diabaikan (dipertahankan), loss hanya dihitung untuk label dalam `[0, ..., config.vocab_size - 1]`.

**Mengembalikan:** [CausalLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutput) atau `tuple(torch.Tensor)`

A [CausalLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.CausalLMOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) dan input.

Metode forward dari [Wav2Vec2ForCTC](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) 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` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### load_adapter[[transformers.Wav2Vec2ForCTC.load_adapter]]

```python
load_adapter(target_lang: str, force_load = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1020)

**Parameter:**

target_lang (`str`) : Harus berupa id bahasa dari bobot adapter yang sudah ada. Bobot adapter disimpan dalam format adapter..safetensors atau adapter..bin

force_load (`bool`, defaultnya `True`) : Apakah bobot akan dimuat meskipun `target_lang` cocok dengan `self.target_lang`.

cache_dir (`Union[str, os.PathLike]`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh harus di-cache jika cache standar tidak digunakan.

force_download (`bool`, *opsional*, default `False`) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang sudah di-cache jika ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Proxy digunakan pada setiap permintaan.

local_files_only(`bool`, *opsional*, default `False`) : Apakah hanya melihat file lokal (yaitu, tidak mencoba mengunduh model).

token (`str` atau `bool`, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, atau tidak ditentukan, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.    Untuk menguji pull request yang Anda buat di Hub, Anda dapat meneruskan `revision="refs/pr/<pr_number>"`.

mirror (`str`, *opsional*) : Sumber cermin untuk mempercepat unduhan di Tiongkok. Jika Anda berasal dari Tiongkok dan mengalami masalah aksesibilitas, Anda dapat mengatur opsi ini untuk menyelesaikannya. Perhatikan bahwa kami tidak menjamin ketepatan waktu atau keamanannya. Silakan merujuk ke situs cermin untuk informasi lebih lanjut.

Muat model adapter bahasa dari model adapter yang telah dilatih sebelumnya.

Aktifkan ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) khusus untuk menggunakan metode ini di lingkungan yang terisolasi oleh firewall.

Contoh:

```python
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor

>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")
```

## Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

#### transformers.Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

```python
transformers.Wav2Vec2ForSequenceClassification(config: Wav2Vec2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1652)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 dengan kepala klasifikasi urutan di atasnya (lapisan linear di atas output yang dipool) untuk tugas seperti SUPERB Keyword Spotting.

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.Wav2Vec2ForSequenceClassification.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1685)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

**Mengembalikan:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau `tuple(torch.Tensor)`

[SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) dan input.

Metode forward dari [Wav2Vec2ForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification) 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` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh klasifikasi label tunggal:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Contoh klasifikasi multi-label:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

#### transformers.Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

```python
transformers.Wav2Vec2ForAudioFrameClassification(config: Wav2Vec2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1745)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 dengan kepala klasifikasi frame di atasnya untuk tugas seperti Speaker Diarization.

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.Wav2Vec2ForAudioFrameClassification.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1777)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

**Mengembalikan:** [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)`

[TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) dan input.

Metode forward dari [Wav2Vec2ForAudioFrameClassification](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForAudioFrameClassification) 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` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor klasifikasi (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...
```

## Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

#### transformers.Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

```python
transformers.Wav2Vec2ForXVector(config: Wav2Vec2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1893)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 dengan kepala ekstraksi fitur XVector di atasnya untuk tugas seperti Verifikasi Pembicara.

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.Wav2Vec2ForXVector.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1943)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) : Nilai float dari waveform ucapan mentah yang diinputkan. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

**Mengembalikan:** [XVectorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.XVectorOutput) atau `tuple(torch.Tensor)`

[XVectorOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.XVectorOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) dan input.

Metode forward dari [Wav2Vec2ForXVector](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector) 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` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) -- Loss klasifikasi.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.xvector_output_dim)`) -- Hidden state klasifikasi sebelum AMSoftmax.
- **embeddings** (`torch.Tensor` dengan bentuk `(batch_size, config.xvector_output_dim)`) -- Embedding ucapan yang digunakan untuk pengambilan berbasis kemiripan vektor.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...
```

## Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

#### transformers.Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

```python
transformers.Wav2Vec2ForPreTraining(config: Wav2Vec2Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1322)

**Parameter:**

config ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 dengan kuantizer dan head `VQ` 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.Wav2Vec2ForPreTraining.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.BoolTensor] = None, sampled_negative_indices: typing.Optional[torch.BoolTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1370)

**Parameter:**

input_values (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Nilai float dari waveform ucapan mentah. Nilai dapat diperoleh dengan memuat file audio `.flac` atau `.wav` ke dalam array bertipe `list[float]`, `numpy.ndarray`, atau `torch.Tensor`, *misalnya* melalui pustaka torchcodec (`pip install torchcodec`) atau pustaka soundfile (`pip install soundfile`). Untuk menyiapkan array menjadi `input_values`, gunakan [AutoProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoProcessor) untuk padding dan konversi menjadi tensor bertipe `torch.Tensor`. Lihat [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) untuk detailnya.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks untuk memasker fitur yang diekstrak untuk kerugian kontrastif. Saat dalam mode pelatihan, model belajar memprediksi fitur yang diekstrak dan dimasker dalam ruang *config.proj_codevector_dim*.

sampled_negative_indices (`torch.BoolTensor` dengan bentuk `(batch_size, sequence_length, num_negatives)`, *opsional*) : Indeks yang menunjukkan vektor target terkuantisasi mana yang digunakan sebagai vektor sampel negatif dalam kerugian kontras. Input yang diperlukan untuk pra-pelatihan.

**Mengembalikan:** [Wav2Vec2ForPreTrainingOutput](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) atau `tuple(torch.Tensor)`

Sebuah [Wav2Vec2ForPreTrainingOutput](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([Wav2Vec2Config](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2Config)) dan input.

Metode forward dari [Wav2Vec2ForPreTraining](/docs/transformers/v5.23.0/id/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining) 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** (`*optional*`, dikembalikan saat `sample_negative_indices` diberikan, `torch.Tensor` dengan bentuk `(1,)`) -- Total loss sebagai jumlah dari contrastive loss (L_m) dan diversity loss (L_d) sebagaimana dinyatakan dalam [paper resmi](https://huggingface.co/papers/2006.11477).
- **projected_states** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Hidden-states dari model yang diproyeksikan ke *config.proj_codevector_dim* yang dapat digunakan untuk memprediksi state kuantisasi terproyeksi yang ter-mask.
- **projected_quantized_states** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Vektor fitur tereksstrak terkuantisasi yang diproyeksikan ke *config.proj_codevector_dim*, yang mewakili vektor target positif untuk kerugian kontras (contrastive loss).
- **codevector_perplexity** (`torch.Tensor` dengan bentuk `(1,)`) -- Perplexity dari distribusi codevector, digunakan untuk mengukur keragaman codebook.
- **hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **contrastive_loss** (`*optional*`, dikembalikan ketika `sample_negative_indices` diberikan, `torch.Tensor` dengan bentuk `(1,)`) -- Kehilangan kontras (L_m) sebagaimana dinyatakan dalam [makalah resmi](https://huggingface.co/papers/2006.11477).
- **diversity_loss** (`*optional*`, dikembalikan saat `sample_negative_indices` diberikan, `torch.Tensor` dengan bentuk `(1,)`) -- Keragaman loss (L_d) sebagaimana dinyatakan dalam [paper resmi](https://huggingface.co/papers/2006.11477).

Contoh:

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
```

