# Wav2Vec2

## Tổng quan

Mô hình Wav2Vec2 được đề xuất trong [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://huggingface.co/papers/2006.11477) bởi Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.

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

*Chúng tôi lần đầu tiên cho thấy rằng việc học các biểu diễn mạnh mẽ chỉ từ âm thanh nói, sau đó tinh chỉnh trên giọng nói đã được chuyển tự, có thể vượt trội hơn các phương pháp bán giám sát tốt nhất trong khi đơn giản hơn về mặt khái niệm. wav2vec 2.0 che mờ (mask) đầu vào giọng nói trong không gian ẩn và giải quyết một bài toán tương phản được định nghĩa trên lượng tử hóa của các biểu diễn ẩn, vốn được học đồng thời. Các thí nghiệm sử dụng toàn bộ dữ liệu có nhãn của Librispeech đạt WER 1,8/3,3 trên các tập kiểm tra clean/other. Khi giảm lượng dữ liệu có nhãn xuống còn một giờ, wav2vec 2.0 vượt trội hơn mức tiên tiến trước đó trên tập con 100 giờ trong khi sử dụng ít hơn 100 lần dữ liệu có nhãn. Chỉ sử dụng mười phút dữ liệu có nhãn và tiền huấn luyện trên 53k giờ dữ liệu không nhãn vẫn đạt WER 4,8/8,2. Điều này chứng minh tính khả thi của nhận dạng giọng nói với lượng dữ liệu có nhãn hạn chế.*

Mô hình này được đóng góp bởi [patrickvonplaten](https://huggingface.co/patrickvonplaten).

Lưu ý: Meta (FAIR) đã phát hành một phiên bản mới của [Wav2Vec2-BERT 2.0](./wav2vec2-bert) - nó được huấn luyện trước trên 4,5 triệu giờ âm thanh. Chúng tôi đặc biệt khuyến nghị sử dụng nó cho các tác vụ tinh chỉnh, ví dụ như theo [hướng dẫn này](https://huggingface.co/blog/fine-tune-w2v2-bert).

> [!TIP]
> Đặt `use_kernels=True` trong [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để thay thế các lớp được hỗ trợ bằng các kernel tối ưu từ Hub. Xem [Tải kernel](../kernel_doc/loading_kernels) để biết thêm.

## Mẹo sử dụng

- Wav2Vec2 là một mô hình giọng nói, nhận vào một mảng float tương ứng với dạng sóng thô của tín hiệu giọng nói.
- Mô hình Wav2Vec2 được huấn luyện bằng phân loại thời gian liên kết (CTC) nên đầu ra của mô hình phải được giải mã bằng [Wav2Vec2CTCTokenizer](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).

## Sử dụng Flash Attention 2

Flash Attention 2 là phiên bản nhanh hơn, được tối ưu hóa của mô hình.

### Cài đặt

Đầu tiên, hãy kiểm tra xem phần cứng của bạn có tương thích với Flash Attention 2 hay không. Danh sách phần cứng tương thích mới nhất có thể được tìm thấy trong [tài liệu chính thức](https://github.com/Dao-AILab/flash-attention#installation-and-features).

Tiếp theo, [cài đặt](https://github.com/Dao-AILab/flash-attention#installation-and-features) phiên bản mới nhất của Flash Attention 2:

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

### Cách sử dụng

Để tải một mô hình sử dụng Flash Attention 2, chúng ta có thể truyền tham số `attn_implementation="flash_attention_2"` vào [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained). Chúng ta cũng sẽ tải mô hình ở độ chính xác nửa (ví dụ `torch.float16`), vì điều này hầu như không làm giảm chất lượng âm thanh nhưng giúp giảm đáng kể lượng bộ nhớ sử dụng và tăng tốc độ suy luận:

```python
from transformers import Wav2Vec2Model

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

### Tốc độ tăng tốc dự kiến

Dưới đây là biểu đồ tốc độ dự kiến so sánh thời gian suy luận thuần túy giữa bản triển khai gốc trong transformers của mô hình `facebook/wav2vec2-large-960h-lv60-self` và các phiên bản flash-attention-2 và sdpa (scale-dot-product-attention). Chúng tôi hiển thị tốc độ tăng trung bình đạt được trên tập kiểm tra `librispeech_asr` `clean`:

## Tài nguyên

Danh sách các tài nguyên chính thức của Hugging Face và cộng đồng (được đánh dấu bằng 🌎) để giúp bạn bắt đầu với Wav2Vec2. Nếu bạn quan tâm đến việc gửi tài nguyên để được đưa vào đây, hãy thoải mái mở một Pull Request và chúng tôi sẽ xem xét! Tài nguyên lý tưởng nên minh họa một điều gì đó mới thay vì sao chép một tài nguyên hiện có.

- Một notebook về cách [lợi dụng một mô hình Wav2Vec2 được huấn luyện trước cho phân loại cảm xúc](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) được hỗ trợ bởi [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb) này.
- [Hướng dẫn tác vụ phân loại âm thanh](../tasks/audio_classification)

- Một bài viết trên blog về [cách tăng cường Wav2Vec2 bằng n-grams trong 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- Một bài viết trên blog về cách [finetune Wav2Vec2 cho ASR tiếng Anh với 🤗 Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- Một bài viết trên blog về [finetuning XLS-R cho Multi-Lingual ASR với 🤗 Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- Một notebook về cách [tạo phụ đề YouTube từ bất kỳ video nào bằng cách chuyển văn bản từ âm thanh bằng Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) được hỗ trợ bởi một notebook về [cách tinh chỉnh mô hình nhận dạng giọng nói bằng tiếng Anh](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb) và [cách tinh chỉnh mô hình nhận dạng giọng nói bằng bất kỳ ngôn ngữ nào](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).
- [Hướng dẫn tác vụ nhận dạng giọng nói tự động](../tasks/asr)

🚀 Triển khai

- Một bài viết trên blog về cách triển khai Wav2Vec2 cho [Nhận dạng giọng nói tự động với Transformers của Hugging Face & Amazon SageMaker](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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/configuration_wav2vec2.py#L27)

**Tham số:**

vocab_size (`int`, *tùy chọn*, mặc định là `32`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

hidden_size (`int`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

intermediate_size (`int`, *tuỳ chọn*, mặc định là `3072`) : Kích thước của các biểu diễn MLP.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

hidden_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler.

activation_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các kích hoạt bên trong lớp liên kết đầy đủ.

attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý.

feat_proj_dropout (`float`, *optional*, mặc định là 0.0) : Xác suất dropout cho đầu ra của bộ mã hóa đặc trưng.

feat_quantizer_dropout (`float`, *optional*, mặc định là 0.0) : Xác suất dropout cho đầu ra của bộ mã hóa đặc trưng được sử dụng bởi bộ lượng tử hóa.

final_dropout (`float`, *tuỳ chọn*, mặc định là 0.1) : Xác suất dropout cho lớp chiếu cuối cùng của [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

layerdrop (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất LayerDrop. Xem [bài báo LayerDrop](see https://huggingface.co/papers/1909.11556) để biết thêm chi tiết.

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

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-05`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

feat_extract_norm (`str`, *tùy chọn*, mặc định là `"group"`) : Chuẩn được áp dụng cho các lớp tích chập 1D trong bộ mã hóa đặc trưng. Một trong `"group"` cho chuẩn hóa nhóm chỉ của lớp tích chập 1D đầu tiên hoặc `"layer"` cho chuẩn hóa lớp của tất cả các lớp tích chập 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]` hoặc `list[int]`, *tùy chọn*, mặc định là `(512, 512, 512, 512, 512, 512, 512)`) : Một tuple các số nguyên xác định số kênh đầu vào và đầu ra của mỗi lớp tích chập 1D trong bộ mã hóa đặc trưng. Độ dài của *conv_dim* xác định số lượng lớp tích chập 1D.

conv_stride (`tuple[int]` hoặc `list[int]`, *tùy chọn*, mặc định là `(5, 2, 2, 2, 2, 2, 2)`) : Một tuple các số nguyên xác định bước nhảy (stride) của mỗi lớp tích chập 1D trong bộ mã hóa đặc trưng. Độ dài của *conv_stride* xác định số lượng lớp tích chập và phải khớp với độ dài của *conv_dim*.

conv_kernel (`tuple[int]` hoặc `list[int]`, *tuỳ chọn*, mặc định là `(10, 3, 3, 3, 3, 3, 3)`) : Một tuple các số nguyên xác định kích thước kernel của từng lớp tích chập 1D trong bộ mã hóa đặc trưng. Độ dài của *conv_kernel* xác định số lượng lớp tích chập và phải khớp với độ dài của *conv_dim*.

conv_bias (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem các lớp tích chập 1D có bias hay không.

num_conv_pos_embeddings (`int`, *optional*, mặc định là 128) : Số lượng nhúng vị trí tích chập. Xác định kích thước nhân của lớp nhúng vị trí tích chập 1D.

num_conv_pos_embedding_groups (`int`, *tuỳ chọn*, mặc định là 16) : Số nhóm của lớp nhúng vị trí tích chập 1 chiều.

do_stable_layer_norm (`bool`, *tuỳ chọn*, mặc định là `False`) : Có áp dụng kiến trúc layer norm *ổn định* của bộ mã hóa Transformer hay không. `do_stable_layer_norm is True` tương ứng với việc áp dụng layer norm trước lớp attention, trong khi `do_stable_layer_norm is False` tương ứng với việc áp dụng layer norm sau lớp attention.

apply_spec_augment (`bool`, *tùy chọn*, mặc định là `True`) : Có áp dụng tăng cường dữ liệu *SpecAugment* cho đầu ra của bộ mã hóa đặc trưng hay không. Để tham khảo, xem [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779).

mask_time_prob (`float`, *optional*, mặc định là 0.05) : Phần trăm (từ 0 đến 1) của tất cả các vector đặc trưng dọc theo trục thời gian sẽ bị che. Quy trình che tạo ra ''mask_time_prob*len(time_axis)/mask_time_length'' các mặt nạ độc lập trên trục. Nếu suy luận từ xác suất của mỗi vector đặc trưng được chọn làm điểm bắt đầu của khoảng vector sẽ bị che, *mask_time_prob* nên là `prob_vector_start*mask_time_length`. Lưu ý rằng sự chồng lấn có thể làm giảm phần trăm thực tế của các vector bị che. Điều này chỉ liên quan nếu `apply_spec_augment is True`.

mask_time_length (`int`, *tuỳ chọn*, mặc định là 10) : Độ dài của vector span dọc theo trục thời gian.

mask_time_min_masks (`int`, *optional*, mặc định là 2), : Số lượng tối thiểu các mask có độ dài `mask_feature_length` được tạo dọc theo trục thời gian, tại mỗi bước thời gian, bất kể `mask_feature_prob`. Chỉ có liên quan nếu ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks''

mask_feature_prob (`float`, *optional*, mặc định là 0.0) : Phần trăm (từ 0 đến 1) của tất cả các vector đặc trưng dọc theo trục đặc trưng sẽ bị che. Quy trình che tạo ra ''mask_feature_prob*len(feature_axis)/mask_time_length'' các mặt nạ độc lập trên trục. Nếu suy luận từ xác suất của mỗi vector đặc trưng được chọn làm điểm bắt đầu của khoảng vector cần che, *mask_feature_prob* nên là `prob_vector_start*mask_feature_length`. Lưu ý rằng sự chồng lấn có thể làm giảm phần trăm thực tế của các vector bị che. Điều này chỉ liên quan nếu `apply_spec_augment is True`.

mask_feature_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Phần trăm (từ 0 đến 1) của tất cả các vector đặc trưng dọc theo trục đặc trưng sẽ bị che. Quy trình che tạo ra `mask_feature_prob*len(feature_axis)/mask_time_length` các mặt nạ độc lập trên trục. Nếu suy luận từ xác suất của mỗi vector đặc trưng được chọn làm điểm bắt đầu của khoảng vector cần che, *mask_feature_prob* nên là `prob_vector_start*mask_feature_length`. Lưu ý rằng sự chồng lấn có thể làm giảm phần trăm thực tế của các vector bị che. Điều này chỉ liên quan nếu `apply_spec_augment` là `True`.

mask_feature_length (`int`, *tuỳ chọn*, mặc định là 10) : Độ dài của vector span dọc theo trục đặc trưng.

mask_feature_min_masks (`int`, *optional*, mặc định là 0), : Số lượng tối thiểu các mặt nạ có độ dài `mask_feature_length` được tạo ra dọc theo trục đặc trưng, ở mỗi bước thời gian, bất kể giá trị của `mask_feature_prob`. Chỉ có ý nghĩa nếu ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''

num_codevectors_per_group (`int`, *optional*, mặc định là 320) : Số lượng mục trong mỗi codebook lượng tử hóa (nhóm).

num_codevectors_per_group (`int`, *optional*, mặc định là 320) : Số lượng mục trong mỗi codebook lượng tử hóa (nhóm).

num_codevector_groups (`int`, *optional*, mặc định là 2) : Số lượng nhóm codevector cho lượng tử hóa codevector tích.

contrastive_logits_temperature (`float`, *tuỳ chọn*, mặc định là 0.1) : Nhiệt độ *kappa* trong tổn thất tương phản.

num_negatives (`int`, *tuỳ chọn*, mặc định là 100) : Số lượng mẫu âm cho tổn thất tương phản.

codevector_dim (`int`, *tuỳ chọn*, mặc định là 256) : Độ chiều của các vector đặc trưng đã lượng tử hóa.

proj_codevector_dim (`int`, *optional*, mặc định là 256) : Độ chiều của phép chiếu cuối cùng cho cả đặc trưng đã lượng tử hóa và đặc trưng của transformer.

diversity_loss_weight (`int`, *optional*, mặc định là 0.1) : Trọng số của thành phần tổn thất đa dạng hóa codebook.

ctc_loss_reduction (`str`, *tùy chọn*, mặc định là `"sum"`) : Xác định phép giảm (reduction) áp dụng cho đầu ra của `torch.nn.CTCLoss`. Chỉ liên quan khi huấn luyện một instance của [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

ctc_zero_infinity (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đặt bằng không các tổn thất vô hạn và các gradient liên quan của `torch.nn.CTCLoss` hay không. Tổn thất vô hạn chủ yếu xảy ra khi các đầu vào quá ngắn để có thể căn chỉnh với các mục tiêu. Chỉ liên quan khi huấn luyện một instance của [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

use_weighted_layer_sum (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng trung bình có trọng số của đầu ra lớp với trọng số được học hay không. Chỉ liên quan khi sử dụng một instance của [Wav2Vec2ForSequenceClassification](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification).

classifier_proj_size (`int`, *optional*, mặc định là 256) : Độ chiều của phép chiếu trước khi thực hiện token mean-pooling cho phân loại.

tdnn_dim (`tuple[int]` hoặc `list[int]`, *tùy chọn*, mặc định là `(512, 512, 512, 512, 1500)`) : Một tuple các số nguyên xác định số lượng kênh đầu ra của mỗi lớp tích chập 1D trong module *TDNN* của mô hình *XVector*. Độ dài của *tdnn_dim* xác định số lượng lớp *TDNN*.

tdnn_kernel (`tuple[int]` hoặc `list[int]`, *tùy chọn*, mặc định là `(5, 3, 3, 1, 1)`) : Một tuple các số nguyên xác định kích thước kernel của mỗi lớp tích chập 1D trong module *TDNN* của mô hình *XVector*. Độ dài của *tdnn_kernel* phải khớp với độ dài của *tdnn_dim*.

tdnn_dilation (`tuple[int]` hoặc `list[int]`, *tùy chọn*, mặc định là `(1, 2, 3, 1, 1)`) : Một tuple các số nguyên xác định hệ số giãn nở của từng lớp tích chập 1D trong module *TDNN* của mô hình *XVector*. Độ dài của *tdnn_dilation* phải khớp với độ dài của *tdnn_dim*.

xvector_output_dim (`int`, *tuỳ chọn*, mặc định là 512) : Độ chiều của các vector nhúng *XVector*.

pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

bos_token_id (`int`, *tuỳ chọn*, mặc định là `1`) : Id của token được sử dụng cho đầu luồng (beginning-of-stream) trong từ vựng.

eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `2`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng.

add_adapter (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên xếp chồng một mạng tích chập lên trên Encoder của Wav2Vec2 hay không. Điều này có thể rất hữu ích để khởi tạo nóng (warm-start) Wav2Vec2 cho các mô hình SpeechEncoderDecoder.

adapter_kernel_size (`int`, *tuỳ chọn*, mặc định là 3) : Kích thước kernel của các lớp tích chập trong mạng adapter. Chỉ liên quan nếu `add_adapter is True`.

adapter_stride (`int`, *tuỳ chọn*, mặc định là 2) : Bước nhảy (stride) của các lớp tích chập trong mạng adapter. Chỉ liên quan nếu `add_adapter is True`.

num_adapter_layers (`int`, *optional*, mặc định là 3) : Số lượng lớp tích chập cần được sử dụng trong mạng adapter. Chỉ liên quan nếu `add_adapter is True`.

output_hidden_size (`int`, *optional*) : Độ chiều của lớp đầu ra bộ mã hóa. Nếu không được định nghĩa, giá trị mặc định là *hidden-size*. Chỉ liên quan nếu `add_adapter is True`.

adapter_attn_dim (`int`, *optional*) : Kích thước của trọng số attention adapter sẽ được sử dụng trong mỗi khối attention. Một ví dụ về mô hình sử dụng attention adapter là [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

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

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

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L101)

**Tham số:**

vocab_file (`str`) : Tệp chứa từ vựng.

bos_token (`str`, *tùy chọn*, mặc định là `"<s>"`) : Token bắt đầu câu.

eos_token (`str`, *tùy chọn*, mặc định là `"</s>"`) : Token kết thúc câu.

unk_token (`str`, *tùy chọn*, mặc định là `"<unk>"`) : Token không xác định. Một token không có trong từ vựng sẽ không thể được chuyển đổi thành ID và sẽ được gán thành token này thay thế.

pad_token (`str`, *tùy chọn*, mặc định là `"<pad>"`) : Token được sử dụng để đệm, chẳng hạn khi xử lý các lô (batch) các chuỗi có độ dài khác nhau.

word_delimiter_token (`str`, *tùy chọn*, mặc định là `"|"`) : Token được sử dụng để xác định kết thúc của một từ.

do_lower_case (`bool`, *tùy chọn*, mặc định là `False`) : Có chấp nhận đầu vào chữ thường và chuyển đầu ra thành chữ thường khi giải mã hay không.

target_lang (`str`, *tùy chọn*) : Ngôn ngữ đích mà tokenizer nên đặt mặc định. `target_lang` phải được định nghĩa cho từ điển lồng nhau đa ngôn ngữ như [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

- ****kwargs** : Các đối số từ khóa bổ sung được truyền đến [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend)

Tạo một tokenizer Wav2Vec2CTC.

Tokenizer này kế thừa từ [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend), bao gồm một số phương thức chính. Người dùng nên tham khảo lớp cha để biết thêm thông tin về các phương thức này.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449)

**Tham số:**

text (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).

text_pair (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).

text_target (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa dưới dạng văn bản đích. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *tuỳ chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa dưới dạng văn bản đích. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu các chuỗi được cung cấp dưới dạng danh sách các chuỗi ký tự (đã tách token trước), bạn phải đặt `is_split_into_words=True` (để loại bỏ sự mơ hồ với một lô các chuỗi).

tokenizer_kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs bổ sung để truyền cho tokenizer. Chúng sẽ được gộp với các tham số tường minh và các kwargs khác, trong đó các tham số tường minh có độ ưu tiên cao hơn.

add_special_tokens (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm các token đặc biệt khi mã hóa các chuỗi hay không. Điều này sẽ sử dụng hàm `PretrainedTokenizerBase.build_inputs_with_special_tokens` bên dưới, hàm này xác định các token nào được thêm tự động vào các id đầu vào. Điều này hữu ích nếu bạn muốn tự động thêm các token `bos` hoặc `eos`.

padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/main/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tuỳ chọn*, mặc định là `False`) : Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau:  - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong lô (hoặc không đệm nếu chỉ cung cấp một chuỗi duy nhất). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một lô với các chuỗi có độ dài khác nhau).

truncation (`bool`, `str` hoặc [TruncationStrategy](/docs/transformers/main/vi/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*, mặc định là `False`) : Kích hoạt và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau:  - `True` hoặc `'longest_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_second'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `False` hoặc `'do_not_truncate'` (mặc định): Không cắt ngắn (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa được phép của mô hình).

max_length (`int`, *optional*) : Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt/giữ chỗ. Nếu không được đặt hoặc được đặt thành `None`, tham số này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa.

stride (`int`, *optional*, mặc định là 0) : Nếu được đặt thành một số cùng với `max_length`, các token tràn được trả về khi `return_overflowing_tokens=True` sẽ chứa một số token từ cuối của chuỗi bị cắt ngắn được trả về để tạo ra một phần chồng lấn giữa các chuỗi bị cắt ngắn và các chuỗi tràn. Giá trị của đối số này xác định số lượng token chồng lấn.

is_split_into_words (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem đầu vào đã được tiền xử lý token hay chưa (ví dụ: đã được tách thành các từ). Nếu đặt thành `True`, bộ phân từ sẽ giả định rằng đầu vào đã được tách thành các từ (chẳng hạn, bằng cách tách theo khoảng trắng) và sẽ tiến hành phân từ chúng. Điều này hữu ích cho NER hoặc phân loại token.

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

padding_side (`str`, *tùy chọn*) : Bên mà mô hình cần được áp dụng padding. Nên chọn trong ['right', 'left']. Giá trị mặc định được lấy từ thuộc tính lớp có cùng tên.

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

return_token_type_ids (`bool`, *tuỳ chọn*) : Có trả về các ID loại token hay không. Nếu để mặc định, sẽ trả về các ID loại token theo mặc định của bộ phân tích token cụ thể, được định nghĩa bởi thuộc tính `return_outputs`.  [ID loại token là gì?](../glossary#token-type-ids)

return_attention_mask (`bool`, *tuỳ chọn*) : Có trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của tokenizer cụ thể, được định nghĩa bởi thuộc tính `return_outputs`.  [Attention mask là gì?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về các chuỗi token bị tràn hay không. Nếu một cặp chuỗi id đầu vào (hoặc một lô các cặp) được cung cấp với `truncation_strategy = longest_first` hoặc `True`, một lỗi sẽ được ném thay vì trả về các token bị tràn.

return_special_tokens_mask (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về thông tin mặt nạ token đặc biệt hay không.

return_offsets_mapping (`bool`, *tùy chọn*, mặc định là `False`) : Có nên trả về `(char_start, char_end)` cho từng token hay không. Tính năng này chỉ khả dụng trên các fast tokenizer kế thừa từ [PreTrainedTokenizerFast](/docs/transformers/main/vi/main_classes/tokenizer#transformers.TokenizersBackend); nếu sử dụng tokenizer của Python, phương thức này sẽ gây ra `NotImplementedError`.

return_length  (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về độ dài của các đầu vào đã mã hóa hay không.

verbose (`bool`, *tùy chọn*, mặc định là `True`) : Có in thêm thông tin và cảnh báo hay không.

- ****kwargs** : được truyền vào phương thức `self.tokenize()`

**Trả về:** [BatchEncoding](/docs/transformers/main/vi/main_classes/tokenizer#transformers.BatchEncoding)

Một [BatchEncoding](/docs/transformers/main/vi/main_classes/tokenizer#transformers.BatchEncoding) với các trường sau:

- **input_ids** -- Danh sách các id token để đưa vào mô hình.

  [ID đầu vào là gì?](../glossary#input-ids)

- **token_type_ids** -- Danh sách các id loại token để đưa vào mô hình (khi `return_token_type_ids=True` hoặc nếu *"token_type_ids"* nằm trong `self.model_input_names`).

  [ID loại token là gì?](../glossary#token-type-ids)

- **attention_mask** -- Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến (khi `return_attention_mask=True` hoặc nếu *"attention_mask"* nằm trong `self.model_input_names`).

  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

- **overflowing_tokens** -- Danh sách các chuỗi token bị tràn (khi `max_length` được chỉ định và `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Số lượng token bị cắt bỏ (khi chỉ định `max_length` và `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Danh sách các số 0 và 1, trong đó 1 chỉ định các token đặc biệt đã thêm và 0 chỉ định các token chuỗi thông thường (khi `add_special_tokens=True` và `return_special_tokens_mask=True`).
- **length** -- Độ dài của các đầu vào (khi `return_length=True`)

Phương thức chính để mã hóa token và chuẩn bị cho mô hình một hoặc nhiều chuỗi, hoặc một hoặc nhiều cặp chuỗi.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L538)

**Tham số:**

token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Danh sách các id đầu vào đã được token hóa. Có thể lấy được bằng cách sử dụng phương thức `__call__`.

skip_special_tokens (`bool`, *tùy chọn*, mặc định là `False`) : Có loại bỏ các token đặc biệt trong quá trình giải mã hay không.

clean_up_tokenization_spaces (`bool`, *tùy chọn*) : Có dọn dẹp khoảng trắng trong token hóa hay không.

output_char_offsets (`bool`, *tùy chọn*, mặc định là `False`) : Có xuất các vị trí ký tự hay không. Các vị trí ký tự có thể được sử dụng kết hợp với tỷ lệ lấy mẫu và tỷ lệ giảm mẫu của mô hình để tính toán mốc thời gian của các ký tự được chuyển tự.    Vui lòng xem ví dụ bên dưới để hiểu rõ hơn cách sử dụng `output_char_offsets`.

output_word_offsets (`bool`, *tùy chọn*, mặc định là `False`) : Có xuất vị trí từ hay không. Vị trí từ có thể được sử dụng kết hợp với tốc độ lấy mẫu và tốc độ hạ mẫu của mô hình để tính toán mốc thời gian của các từ được chuyển tự.    Hãy xem ví dụ bên dưới để hiểu rõ hơn cách sử dụng `output_word_offsets`.

kwargs (các đối số từ khóa bổ sung, *tùy chọn*) : Sẽ được truyền đến phương thức giải mã cụ thể của mô hình cơ sở.

**Trả về:** `str` hoặc `Wav2Vec2CTCTokenizerOutput`

Danh sách các câu đã giải mã. Sẽ là `Wav2Vec2CTCTokenizerOutput` khi `output_char_offsets == True` hoặc `output_word_offsets == True`.

Chuyển đổi một chuỗi các id trong một chuỗi ký tự, sử dụng tokenizer và từ vựng với các tùy chọn để loại bỏ các token đặc biệt và dọn dẹp khoảng trắng trong quá trình token hóa.

Tương tự như việc thực hiện `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L468)

**Tham số:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Danh sách các id đầu vào đã được token hóa. Có thể lấy được bằng cách sử dụng phương thức `__call__`.

skip_special_tokens (`bool`, *tùy chọn*, mặc định là `False`) : Có loại bỏ các token đặc biệt trong quá trình giải mã hay không.

clean_up_tokenization_spaces (`bool`, *tùy chọn*) : Có dọn dẹp khoảng trắng trong token hóa hay không.

output_char_offsets (`bool`, *tuỳ chọn*, mặc định là `False`) : Có xuất ra các chỉ số ký tự hay không. Các chỉ số ký tự có thể được sử dụng kết hợp với tỷ lệ lấy mẫu và tỷ lệ giảm mẫu của mô hình để tính toán mốc thời gian của các ký tự được chuyển đổi.    Vui lòng xem Ví dụ của [decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) để hiểu rõ hơn cách sử dụng `output_char_offsets`. [batch_decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) hoạt động theo cách tương tự với đầu ra dạng lô.

output_word_offsets (`bool`, *tuỳ chọn*, mặc định là `False`) : Có xuất ra các vị trí từ (word offsets) hay không. Các vị trí từ có thể được sử dụng kết hợp với tốc độ lấy mẫu và tốc độ hạ mẫu của mô hình để tính toán mốc thời gian của các từ được chuyển tự.    Vui lòng xem Ví dụ của [decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) để hiểu rõ hơn cách sử dụng `output_word_offsets`. [batch_decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) hoạt động theo cách tương tự với đầu ra dạng lô (batched output).

kwargs (các đối số từ khóa bổ sung, *tùy chọn*) : Sẽ được truyền đến phương thức giải mã cụ thể của mô hình cơ sở.

**Trả về:** `list[str]` hoặc `Wav2Vec2CTCTokenizerOutput`

Danh sách các câu đã giải mã. Sẽ là `Wav2Vec2CTCTokenizerOutput` khi `output_char_offsets == True` hoặc `output_word_offsets == True`.

Chuyển đổi một danh sách các danh sách id token thành một danh sách các chuỗi bằng cách gọi decode.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L184)

Đặt ngôn ngữ đích của một từ điển đa ngôn ngữ lồng nhau

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L28)

**Tham số:**

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

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

padding_value (`float`, *tuỳ chọn*, mặc định là 0.0) : Giá trị được sử dụng để điền vào các giá trị đệm (padding).

do_normalize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuẩn hóa đầu vào theo phương pháp trung bình bằng không và phương sai đơn vị hay không. Việc chuẩn hóa có thể giúp cải thiện đáng kể hiệu suất cho một số mô hình, *ví dụ*, [wav2vec2-lv60](https://huggingface.co/models?search=lv60).

return_attention_mask (`bool`, *tuỳ chọn*, mặc định là `False`) : Xác định xem [__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) có nên trả về `attention_mask` hay không.    Các mô hình Wav2Vec2 đã đặt `config.feat_extract_norm == "group"`, chẳng hạn như [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **không** được huấn luyện bằng `attention_mask`. Đối với các mô hình như vậy, `input_values` chỉ cần được đệm bằng 0 và không nên truyền `attention_mask`.  Đối với các mô hình Wav2Vec2 đã đặt `config.feat_extract_norm == "layer"`, chẳng hạn như [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), cần truyền `attention_mask` cho suy luận theo lô.

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

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

#### __call__[[transformers.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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L99)

**Tham số:**

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

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

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

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

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

return_attention_mask (`bool`, *tuỳ chọn*) : Có nên trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của feature_extractor cụ thể.  [Attention mask là gì?](../glossary#attention-mask)    Các mô hình Wav2Vec2 đã đặt `config.feat_extract_norm == "group"`, chẳng hạn như [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), **không** được huấn luyện bằng `attention_mask`. Đối với các mô hình như vậy, `input_values` chỉ cần được đệm bằng 0 và không nên truyền `attention_mask`.  Đối với các mô hình Wav2Vec2 đã đặt `config.feat_extract_norm == "layer"`, chẳng hạn như [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), cần truyền `attention_mask` cho suy luận theo lô (batched inference).

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

sampling_rate (`int`, *optional*) : Tốc độ lấy mẫu mà đầu vào `raw_speech` được lấy mẫu. Rất khuyến nghị truyền `sampling_rate` trong lời gọi forward để ngăn các lỗi âm thầm.

padding_value (`float`, *tùy chọn*, mặc định là 0.0) --

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

## Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.py#L28)

**Tham số:**

feature_extractor (`Wav2Vec2FeatureExtractor`) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

tokenizer (`Wav2Vec2CTCTokenizer`) : Tokenizer là một đầu vào bắt buộc.

Tạo một Wav2Vec2Processor đóng gói một bộ trích xuất đặc trưng và một bộ phân từ thành một bộ xử lý duy nhất.

[Wav2Vec2Processor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor) cung cấp đầy đủ các chức năng của [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) và [Wav2Vec2CTCTokenizer](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer). Xem [~Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) và [~Wav2Vec2CTCTokenizer](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer) để biết thêm thông tin.

#### __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.models.wav2vec2.processing_wav2vec2.Wav2Vec2ProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.py#L32)

**Tham số:**

audio (`Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]]`, *tuỳ chọn*) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh.

text (`Union[str, list[str]]`, *tùy chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu bạn truyền vào đầu vào đã được tách token trước, hãy đặt `is_split_into_words=True` để tránh nhầm lẫn với các đầu vào dạng lô.

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

**Trả về:**

Phương thức này trả về kết quả của mỗi phương thức `call`. Nếu cả hai đều được sử dụng, đầu ra sẽ là một từ điển chứa kết quả của cả hai.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.py#L65)

**Tham số:**

input_features : Khi đối số đầu tiên là một từ điển chứa một lô tensor, hoặc đối số `input_features` có mặt, nó sẽ được truyền đến [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

labels : Khi đối số `label` có mặt, nó sẽ được truyền đến [PreTrainedTokenizer.pad()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).

**Trả về:**

Phương thức này trả về kết quả của từng phương thức `pad`. Nếu cả hai đều được sử dụng, đầu ra sẽ là một từ điển chứa kết quả của cả hai.

Phương pháp này hoạt động trên các lô (batch) các đặc trưng đã trích xuất và/hoặc văn bản đã token hóa. Nó chuyển tiếp tất cả các đối số đến [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) và/hoặc [PreTrainedTokenizer.pad()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) tùy thuộc vào loại dữ liệu đầu vào (modality) và trả về kết quả của chúng. Nếu cả hai loại dữ liệu đều được truyền vào, [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) và [PreTrainedTokenizer.pad()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) sẽ được gọi.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1750)

**Tham số:**

pretrained_model_name_or_path (`str` hoặc `os.PathLike`) : Có thể là một trong các trường hợp sau:  - một chuỗi, *model id* của một feature_extractor được huấn luyện trước và lưu trữ trong kho model trên huggingface.co. - đường dẫn đến một *thư mục* chứa tệp feature extractor đã được lưu bằng phương thức [save_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), ví dụ: `./my_model_directory/`. - đường dẫn đến tệp JSON *file* của feature extractor đã lưu, ví dụ: `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Các đối số từ khóa bổ sung được truyền đến cả [from_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) và `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Tạo một processor liên kết với một model được huấn luyện trước.

Phương thức lớp này đơn giản là gọi phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) của bộ trích xuất đặc trưng, [ImageProcessingMixin](/docs/transformers/main/vi/internal/image_processing_utils#transformers.ImageProcessingMixin) của bộ xử lý ảnh và `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` của bộ phân từ. Vui lòng tham khảo các docstring của các phương thức ở trên để biết thêm thông tin.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1165)

**Tham số:**

save_directory (`str` hoặc `os.PathLike`) : Thư mục nơi tệp JSON của feature extractor và các tệp tokenizer sẽ được lưu (thư mục sẽ được tạo nếu chưa tồn tại).

push_to_hub (`bool`, *tùy chọn*, mặc định là `False`) : Có đẩy mô hình của bạn lên Hugging Face model hub sau khi lưu hay không. Bạn có thể chỉ định kho lưu trữ muốn đẩy đến bằng `repo_id` (mặc định sẽ là tên của `save_directory` trong namespace của bạn).

kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung được truyền đến phương thức [push_to_hub()](/docs/transformers/main/vi/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Lưu các thuộc tính của bộ xử lý này (bộ trích xuất đặc trưng, bộ phân từ...) vào thư mục được chỉ định để có thể tải lại bằng phương thức [from_pretrained()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Phương thức lớp này đơn giản chỉ gọi [save_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) và [save_pretrained()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Vui lòng tham khảo docstring của các phương thức ở trên để biết thêm thông tin.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005)

Phương pháp này chuyển tiếp tất cả các đối số của nó đến [batch_decode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) của PreTrainedTokenizer. Vui lòng tham khảo docstring của phương pháp này để biết thêm thông tin.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014)

Phương pháp này chuyển tiếp tất cả các đối số của nó đến [decode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) của PreTrainedTokenizer. Vui lòng tham khảo docstring của phương pháp này để biết thêm thông tin.

## Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L69)

**Tham số:**

feature_extractor (`feature_extractor_class`) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

tokenizer (`tokenizer_class`) : Tokenizer là đầu vào bắt buộc.

decoder (`BeamSearchDecoderCTC`) : Một instance của `pyctcdecode.BeamSearchDecoderCTC`. Decoder là một đầu vào bắt buộc.

Tạo một Wav2Vec2ProcessorWithLM, đóng gói một bộ trích xuất đặc trưng và một bộ phân từ thành một bộ xử lý duy nhất.

[Wav2Vec2ProcessorWithLM](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) cung cấp đầy đủ các chức năng của `feature_extractor_class` và `tokenizer_class`. Xem `~feature_extractor_class` và `~tokenizer_class` để biết thêm thông tin.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L208)

**Tham số:**

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L233)

Khi được sử dụng ở chế độ bình thường, phương thức này chuyển tiếp tất cả các đối số của nó đến `~FeatureExtractionMixin.pad` của bộ trích xuất đặc trưng và trả về kết quả đầu ra của nó. Nếu được sử dụng trong ngữ cảnh `~Wav2Vec2ProcessorWithLM.as_target_processor`, phương thức này chuyển tiếp tất cả các đối số của nó đến [pad()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) của Wav2Vec2CTCTokenizer. Vui lòng tham khảo docstring của hai phương thức nêu trên để biết thêm thông tin.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L106)

**Tham số:**

pretrained_model_name_or_path (`str` hoặc `os.PathLike`) : Có thể là một trong các trường hợp sau:  - một chuỗi, *model id* của một feature_extractor được huấn luyện trước và lưu trữ trong kho model trên huggingface.co. - đường dẫn đến một *thư mục* chứa tệp feature extractor đã được lưu bằng phương thức [save_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), ví dụ: `./my_model_directory/`. - đường dẫn đến tệp JSON *file* của feature extractor đã lưu, ví dụ: `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Các đối số từ khóa bổ sung được truyền đến cả [SequenceFeatureExtractor](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) và [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend)

Tạo một [Wav2Vec2ProcessorWithLM](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) từ một bộ xử lý Wav2Vec2 được huấn luyện trước.

Phương thức lớp này đơn giản là gọi [from_pretrained()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) của feature extractor, [from_pretrained()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained) của Wav2Vec2CTCTokenizer và `pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub`.

Vui lòng tham khảo các docstring của các phương thức ở trên để biết thêm thông tin.

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

```python
save_pretrained(save_directory)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L102)

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L260)

**Tham số:**

logits (`np.ndarray`) : Vector logits đầu ra của mô hình, đại diện cho log xác suất của từng token.

pool (`multiprocessing.Pool`, *tùy chọn*) : Một pool do người dùng quản lý, tùy chọn. Nếu không được đặt, một pool sẽ được tạo và đóng tự động. Pool nên được khởi tạo *sau* `Wav2Vec2ProcessorWithLM`. Nếu không, LM sẽ không khả dụng cho các tiến trình con của pool.    Hiện tại, chỉ các pool được tạo với ngữ cảnh 'fork' mới có thể được sử dụng. Nếu một pool 'spawn' được truyền vào, nó sẽ bị bỏ qua và giải mã tuần tự sẽ được sử dụng thay thế.

num_processes (`int`, *optional*) : Nếu `pool` không được đặt, số lượng tiến trình mà hàm nên được song song hóa trên. Mặc định là số lượng CPU khả dụng.

beam_width (`int`, *optional*) : Số lượng beam tối đa ở mỗi bước trong quá trình giải mã. Mặc định là DEFAULT_BEAM_WIDTH của pyctcdecode.

beam_prune_logp (`int`, *optional*) : Các beam kém hơn nhiều so với beam tốt nhất sẽ bị loại bỏ. Mặc định là DEFAULT_PRUNE_LOGP của pyctcdecode.

token_min_logp (`int`, *tuỳ chọn*) : Các token có logp thấp hơn ngưỡng này sẽ bị bỏ qua trừ khi chúng là argmax của khung. Mặc định là DEFAULT_MIN_TOKEN_LOGP của pyctcdecode.

hotwords (`list[str]`, *tùy chọn*) : Danh sách các từ có tầm quan trọng đặc biệt, có thể là OOV đối với LM

hotword_weight (`int`, *tuỳ chọn*) : Hệ số trọng số cho mức độ quan trọng của từ khóa. Mặc định là DEFAULT_HOTWORD_WEIGHT của pyctcdecode.

alpha (`float`, *tùy chọn*) : Trọng số cho mô hình ngôn ngữ trong quá trình dung hợp nông

beta (`float`, *tùy chọn*) : Trọng số để điều chỉnh điểm độ dài trong quá trình chấm điểm

unk_score_offset (`float`, *tùy chọn*) : Lượng bù điểm log cho các token không xác định

lm_score_boundary (`bool`, *tùy chọn*) : Có nên để kenlm tôn trọng các ranh giới khi chấm điểm hay không

output_word_offsets (`bool`, *tùy chọn*, mặc định là `False`) : Có xuất ra các vị trí từ hay không. Các vị trí từ có thể được sử dụng kết hợp với tốc độ lấy mẫu và tốc độ hạ mẫu của mô hình để tính toán mốc thời gian của các từ được chuyển tự.

n_best (`int`, *optional*, mặc định là `1`) : Số lượng giả thuyết tốt nhất cần trả về. Nếu `n_best` lớn hơn 1, `text` được trả về sẽ là một danh sách các danh sách chuỗi, `logit_score` sẽ là một danh sách các danh sách số float, và `lm_score` sẽ là một danh sách các danh sách số float, trong đó độ dài của danh sách ngoài tương ứng với kích thước batch và độ dài của danh sách trong tương ứng với số lượng giả thuyết được trả về. Giá trị này phải >= 1.    Vui lòng xem Ví dụ của [decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) để hiểu rõ hơn cách sử dụng `output_word_offsets`. [batch_decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) hoạt động theo cách tương tự với đầu ra dạng batch.

**Trả về:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Giải mã hàng loạt đầu ra logits thành bản ghi âm thanh với hỗ trợ mô hình ngôn ngữ.

Hàm này sử dụng multiprocessing của Python. Hiện tại, multiprocessing chỉ khả dụng trên các hệ thống Unix (xem [vấn đề](https://github.com/kensho-technologies/pyctcdecode/issues/65) này).

Nếu bạn đang giải mã nhiều lô, hãy cân nhắc tạo một `Pool` và truyền nó vào `batch_decode`. Nếu không, `batch_decode` sẽ rất chậm vì nó sẽ tạo một `Pool` mới cho mỗi lần gọi. Xem ví dụ sử dụng bên dưới.

Ví dụ: Xem [Giải mã nhiều tệp âm thanh](#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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L445)

**Tham số:**

logits (`np.ndarray`) : Vector logits đầu ra của mô hình, đại diện cho log xác suất của từng token.

beam_width (`int`, *optional*) : Số lượng beam tối đa ở mỗi bước trong quá trình giải mã. Mặc định là DEFAULT_BEAM_WIDTH của pyctcdecode.

beam_prune_logp (`int`, *optional*) : Ngưỡng để loại bỏ các beam có log-probs nhỏ hơn best_beam_logp + beam_prune_logp. Giá trị phải <= 0. Mặc định là DEFAULT_PRUNE_LOGP của pyctcdecode.

token_min_logp (`int`, *tuỳ chọn*) : Các token có log-prob thấp hơn token_min_logp sẽ bị bỏ qua trừ khi chúng có log-prob lớn nhất cho một câu nói. Mặc định là DEFAULT_MIN_TOKEN_LOGP của pyctcdecode.

hotwords (`list[str]`, *tùy chọn*) : Danh sách các từ có tầm quan trọng đặc biệt, có thể không có trong từ vựng của LM, ví dụ: ["huggingface"]

hotword_weight (`int`, *tuỳ chọn*) : Hệ số nhân trọng số giúp tăng điểm cho từ khóa nóng. Mặc định là DEFAULT_HOTWORD_WEIGHT của pyctcdecode.

alpha (`float`, *tùy chọn*) : Trọng số cho mô hình ngôn ngữ trong quá trình dung hợp nông

beta (`float`, *tùy chọn*) : Trọng số để điều chỉnh điểm độ dài trong quá trình chấm điểm

unk_score_offset (`float`, *tùy chọn*) : Lượng bù điểm log cho các token không xác định

lm_score_boundary (`bool`, *tùy chọn*) : Có nên để kenlm tôn trọng các ranh giới khi chấm điểm hay không

output_word_offsets (`bool`, *tùy chọn*, mặc định là `False`) : Có xuất ra các vị trí từ hay không. Các vị trí từ có thể được sử dụng kết hợp với tốc độ lấy mẫu và tốc độ hạ mẫu của mô hình để tính toán mốc thời gian của các từ được chuyển tự.

n_best (`int`, *tuỳ chọn*, mặc định là `1`) : Số lượng giả thuyết tốt nhất cần trả về. Nếu `n_best` lớn hơn 1, `text` được trả về sẽ là một danh sách các chuỗi, `logit_score` sẽ là một danh sách các số float, và `lm_score` sẽ là một danh sách các số float, trong đó độ dài của các danh sách này sẽ tương ứng với số lượng giả thuyết được trả về. Giá trị phải >= 1.    Vui lòng xem ví dụ bên dưới để hiểu rõ hơn cách sử dụng `output_word_offsets`.

**Trả về:**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Giải mã logits đầu ra thành bản ghi âm thanh với hỗ trợ mô hình ngôn ngữ.

Ví dụ:

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

### Giải mã nhiều tệp âm thanh

Nếu bạn dự định giải mã nhiều lô âm thanh, bạn nên cân nhắc sử dụng [batch_decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) và truyền vào một `multiprocessing.Pool` đã được khởi tạo. Nếu không, hiệu suất của [batch_decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) sẽ chậm hơn so với việc gọi [decode()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) cho từng âm thanh riêng lẻ, vì nó khởi tạo một `Pool` mới bên trong cho mỗi lần gọi. Xem ví dụ bên dưới:

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

## Đầu ra cụ thể của 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L46)

**Tham số:**

text (danh sách `str` hoặc `str`) : Logits đã giải mã từ văn bản. Thường là bản ghi âm thanh.

logit_score (danh sách `float` hoặc `float`) : Tổng điểm logit của các beam liên quan đến văn bản được tạo ra.

lm_score (danh sách `float`) : lm_score đã được hợp nhất của các beam liên quan đến văn bản được tạo ra.

word_offsets (danh sách `list[dict[str, Union[int, str]]]` hoặc `list[dict[str, Union[int, str]]]`) : Các offset của các từ đã được giải mã. Khi kết hợp với tần số lấy mẫu và tỷ lệ hạ mẫu của mô hình, các offset từ có thể được sử dụng để tính toán mốc thời gian cho từng từ.

Loại đầu ra của `Wav2Vec2DecoderWithLM`, kèm theo bản chuyển tự.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1299)

**Tham số:**

last_hidden_state (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của mô hình.

extract_features (`torch.Tensor` có hình dạng `(batch_size, sequence_length, conv_dim[-1])`) : Chuỗi các vector đặc trưng được trích xuất từ lớp tích chập cuối cùng của mô hình.

hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.  Hidden-states của mô hình tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu.

attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.  Trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention heads).

Lớp cơ sở cho các mô hình đã được huấn luyện với mục tiêu tổn thất 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L75)

**Tham số:**

loss (`*optional*`, được trả về khi truyền `sample_negative_indices`, `torch.Tensor` có shape `(1,)`) : Tổng loss là tổng của contrastive loss (L_m) và diversity loss (L_d) như đã nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).

projected_states (`torch.Tensor` có shape `(batch_size, sequence_length, config.proj_codevector_dim)`) : Hidden-states của model được chiếu (project) lên *config.proj_codevector_dim*, có thể dùng để dự đoán các trạng thái lượng tử hóa đã bị che (masked) sau khi chiếu.

projected_quantized_states (`torch.Tensor` có shape `(batch_size, sequence_length, config.proj_codevector_dim)`) : Các vector đặc trưng trích xuất đã lượng tử hóa, được chiếu lên *config.proj_codevector_dim*, đại diện cho các vector đích dương cho contrastive loss.

codevector_perplexity (`torch.Tensor` có shape `(1,)`) : Độ bất ngờ (perplexity) của phân phối codevector, được dùng để đo mức độ đa dạng của codebook.

hidden_states (`tuple[torch.Tensor]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu model có lớp embedding, + một cho đầu ra của mỗi lớp) có shape `(batch_size, sequence_length, hidden_size)`. Hidden-states của model tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu tùy chọn.

attentions (`tuple[torch.Tensor]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.  Trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).

contrastive_loss (`*optional*`, được trả về khi `sample_negative_indices` được truyền vào, `torch.Tensor` có hình dạng `(1,)`) : Mất đối lập (L_m) như được nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).

diversity_loss (`*optional*`, được trả về khi `sample_negative_indices` được truyền vào, `torch.Tensor` có hình dạng `(1,)`) : Tổn đa dạng (L_d) như được nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).

Loại đầu ra của [Wav2Vec2ForPreTraining](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining), có thể bao gồm trạng thái ẩn và chú ý.

## Wav2Vec2Model[[transformers.Wav2Vec2Model]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1194)

**Tham số:**

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

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

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1268)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các giá trị float của waveform âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số để mask các đặc trưng đã trích xuất cho loss tương phản. Khi ở chế độ huấn luyện, mô hình học cách dự đoán các đặc trưng đã trích xuất bị mask trong không gian *config.proj_codevector_dim*.

**Trả về:** [Wav2Vec2BaseModelOutput](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) hoặc `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **extract_features** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, conv_dim[-1])`) -- Chuỗi các vector đặc trưng đã trích xuất từ lớp tích chập cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của lớp nhúng ban đầu.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1522)

**Tham số:**

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

target_lang (`str`, *tùy chọn*) : Id ngôn ngữ của trọng số adapter. Trọng số adapter được lưu dưới định dạng adapter..safetensors hoặc adapter..bin. Chỉ liên quan khi sử dụng một instance của [Wav2Vec2ForCTC](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) với adapters. Mặc định sử dụng 'eng'.

Mô hình Wav2Vec2 với đầu `language modeling` phía trên cho Connectionist Temporal Classification (CTC).

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1591)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các giá trị float của waveform âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

labels (`torch.LongTensor` có hình dạng `(batch_size, target_length)`, *tùy chọn*) : Nhãn cho phân loại thời gian kết nối. Lưu ý rằng `target_length` phải nhỏ hơn hoặc bằng độ dài chuỗi của logits đầu ra. Các chỉ số được chọn trong `[-100, 0, ..., config.vocab_size - 1]`. Tất cả các nhãn được đặt thành `-100` sẽ bị bỏ qua (che), loss chỉ được tính cho các nhãn trong `[0, ..., config.vocab_size - 1]`.

**Trả về:** [CausalLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.CausalLMOutput) hoặc `tuple(torch.Tensor)`

Một [CausalLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.CausalLMOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([Wav2Vec2Config](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Config)) và đầu vào.

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

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

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss của language modeling (cho next-token prediction).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1017)

**Tham số:**

target_lang (`str`) : Phải là id ngôn ngữ của một trọng số adapter hiện có. Trọng số adapter được lưu dưới định dạng adapter..safetensors hoặc adapter..bin

force_load (`bool`, mặc định là `True`) : Xác định xem có nên tải trọng số ngay cả khi `target_lang` khớp với `self.target_lang` hay không.

cache_dir (`Union[str, os.PathLike]`, *tùy chọn*) : Đường dẫn đến thư mục mà cấu hình mô hình được huấn luyện trước đã tải xuống sẽ được lưu vào bộ nhớ đệm nếu không sử dụng bộ nhớ đệm tiêu chuẩn.

force_download (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.

proxies (`dict[str, str]`, *tùy chọn*) : Một từ điển các máy chủ proxy để sử dụng theo giao thức hoặc điểm cuối, ví dụ: `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Các proxy được sử dụng cho mỗi yêu cầu.

local_files_only(`bool`, *tùy chọn*, mặc định là `False`) : Có chỉ xem các tệp cục bộ hay không (tức là không cố gắng tải xuống mô hình).

token (`str` hoặc `bool`, *tùy chọn*) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là `True`, hoặc không được chỉ định, sẽ sử dụng token được tạo khi chạy `hf auth login` (được lưu trong `~/.huggingface`).

revision (`str`, *tùy chọn*, mặc định là `"main"`) : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ hoặc id commit, vì chúng tôi sử dụng hệ thống dựa trên git để lưu trữ các mô hình và các sản phẩm khác trên huggingface.co, do đó `revision` có thể là bất kỳ định danh nào được git cho phép.    Để kiểm tra một pull request bạn đã tạo trên Hub, bạn có thể truyền `revision="refs/pr/<pr_number>"`.

mirror (`str`, *tùy chọn*) : Nguồn mirror để tăng tốc tải xuống tại Trung Quốc. Nếu bạn ở Trung Quốc và gặp vấn đề về khả năng truy cập, bạn có thể đặt tùy chọn này để khắc phục. Lưu ý rằng chúng tôi không đảm bảo tính kịp thời hay an toàn. Vui lòng tham khảo trang mirror để biết thêm thông tin.

Tải một mô hình adapter ngôn ngữ từ một mô hình adapter đã được huấn luyện trước.

Kích hoạt ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) đặc biệt để sử dụng phương pháp này trong môi trường có tường lửa.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1649)

**Tham số:**

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

Mô hình Wav2Vec2 với một đầu phân loại chuỗi phía trên (một lớp tuyến tính trên đầu ra đã được gộp) cho các tác vụ như SUPERB Keyword Spotting.

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1682)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`) : Các giá trị float của dạng sóng âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết thêm chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

**Trả về:** [SequenceClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) hoặc `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss phân loại (hoặc hồi quy nếu config.num_labels==1).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ về phân loại nhãn đơn:

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

Ví dụ về phân loại đa nhãn:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1742)

**Tham số:**

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

Mô hình Wav2Vec2 với một đầu phân loại khung (frame classification head) ở trên cùng cho các tác vụ như Speaker Diarization.

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1774)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`) : Các giá trị float của dạng sóng âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết thêm chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

**Trả về:** [TokenClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) hoặc `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.num_labels)`) -- Điểm phân loại (trước SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1888)

**Tham số:**

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

Mô hình Wav2Vec2 với đầu trích xuất đặc trưng XVector phía trên cho các tác vụ như Xác minh người nói.

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1938)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`) : Các giá trị float của dạng sóng âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết thêm chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

**Trả về:** [XVectorOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.XVectorOutput) hoặc `tuple(torch.Tensor)`

Một [XVectorOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.XVectorOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([Wav2Vec2Config](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Config)) và đầu vào.

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

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

- **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn phân loại.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.xvector_output_dim)`) -- Trạng thái ẩn phân loại trước AMSoftmax.
- **embeddings** (`torch.Tensor` có shape `(batch_size, config.xvector_output_dim)`) -- Các embeddings của câu nói được sử dụng cho việc truy xuất dựa trên độ tương tự vector.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của lớp nhúng ban đầu.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1319)

**Tham số:**

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

Mô hình Wav2Vec2 có bộ lượng tử hóa và đầu `VQ` phía trên.

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

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

#### forward[[transformers.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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1367)

**Tham số:**

input_values (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các giá trị float của waveform âm thanh thô đầu vào. Các giá trị này có thể được lấy bằng cách nạp tệp âm thanh `.flac` hoặc `.wav` vào một mảng có kiểu `list[float]`, một `numpy.ndarray` hoặc một `torch.Tensor`, *ví dụ* thông qua thư viện torchcodec (`pip install torchcodec`) hoặc thư viện soundfile (`pip install soundfile`). Để chuẩn bị mảng thành `input_values`, cần sử dụng [AutoProcessor](/docs/transformers/main/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem [Wav2Vec2Processor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) để biết chi tiết.

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số để mask các đặc trưng đã trích xuất cho loss tương phản. Khi ở chế độ huấn luyện, mô hình học cách dự đoán các đặc trưng đã trích xuất bị mask trong không gian *config.proj_codevector_dim*.

sampled_negative_indices (`torch.BoolTensor` có shape `(batch_size, sequence_length, num_negatives)`, *tùy chọn*) : Các chỉ số cho biết vector target đã lượng tử hóa nào được sử dụng làm vector mẫu âm trong tổn thất tương phản. Đầu vào bắt buộc cho tiền huấn luyện.

**Trả về:** [Wav2Vec2ForPreTrainingOutput](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) hoặc `tuple(torch.Tensor)`

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

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

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

- **loss** (`*optional*`, được trả về khi truyền `sample_negative_indices`, `torch.Tensor` có shape `(1,)`) -- Tổng loss là tổng của contrastive loss (L_m) và diversity loss (L_d) như đã nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).
- **projected_states** (`torch.Tensor` có shape `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Hidden-states của model đã được chiếu (project) lên *config.proj_codevector_dim*, có thể được sử dụng để dự đoán các trạng thái lượng tử hóa đã bị che (masked) và đã được chiếu.
- **projected_quantized_states** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Các vector đặc trưng đã trích xuất và lượng tử hóa, được chiếu lên *config.proj_codevector_dim*, đại diện cho các vector đích dương cho tổn thất tương phản.
- **codevector_perplexity** (`torch.Tensor` có hình dạng `(1,)`) -- Độ bất ngờ (perplexity) của phân phối codevector, được sử dụng để đo lường tính đa dạng của codebook.
- **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **contrastive_loss** (`*optional*`, được trả về khi truyền `sample_negative_indices`, `torch.Tensor` có shape `(1,)`) -- Mất tương phản (L_m) như được nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).
- **diversity_loss** (`*optional*`, được trả về khi truyền `sample_negative_indices`, `torch.Tensor` có shape `(1,)`) -- Mất đa dạng (L_d) như được nêu trong [bài báo chính thức](https://huggingface.co/papers/2006.11477).

Ví dụ:

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