# Wav2Vec2-Conformer

## Tổng quan

Wav2Vec2-Conformer đã được thêm vào phiên bản cập nhật của [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://huggingface.co/papers/2010.05171) do Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino thực hiện.

Kết quả chính thức của mô hình có thể được tìm thấy trong Bảng 3 và Bảng 4 của bài báo.

Trọng số của Wav2Vec2-Conformer đã được nhóm Meta AI phát hành trong [thư viện Fairseq](https://github.com/pytorch/fairseq/blob/main/examples/wav2vec/README.md#pre-trained-models).

Mô hình này được đóng góp bởi [patrickvonplaten](https://huggingface.co/patrickvonplaten). Mã gốc có thể được tìm thấy [tại đây](https://github.com/pytorch/fairseq/tree/main/examples/wav2vec).

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

## Mẹo sử dụng

- Wav2Vec2-Conformer tuân theo cùng kiến trúc như Wav2Vec2, nhưng thay thế khối *Attention* bằng khối *Conformer* như được giới thiệu trong [Conformer: Convolution-augmented Transformer for Speech Recognition](https://huggingface.co/papers/2005.08100).
- Với cùng số lượng lớp, Wav2Vec2-Conformer yêu cầu nhiều tham số hơn so với Wav2Vec2, nhưng cũng cho
tỷ lệ lỗi từ được cải thiện.
- Wav2Vec2-Conformer sử dụng cùng một tokenizer và feature extractor như Wav2Vec2.
- Wav2Vec2-Conformer có thể sử dụng một trong ba loại: không dùng position embeddings, position embeddings kiểu Transformer-XL, hoặc rotary position embeddings, bằng cách đặt giá trị đúng cho `config.position_embeddings_type`.

## Tài nguyên

- [Hướng dẫn tác vụ phân loại âm thanh](../tasks/audio_classification)
- [Hướng dẫn tác vụ nhận dạng giọng nói tự động](../tasks/asr)

## Wav2Vec2ConformerConfig[[transformers.Wav2Vec2ConformerConfig]]

#### transformers.Wav2Vec2ConformerConfig[[transformers.Wav2Vec2ConformerConfig]]

```python
transformers.Wav2Vec2ConformerConfig(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 = None, 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, 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, position_embeddings_type: str | None = 'relative', rotary_embedding_base: int = 10000, max_source_positions: int = 5000, conv_depthwise_kernel_size: int = 31, conformer_conv_dropout: float | int = 0.1)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/configuration_wav2vec2_conformer.py#L27)

**Tham số:**

vocab_size (`int`, *tùy chọn*) : 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 [Wav2Vec2ConformerForCTC](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC).

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.

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.

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 [Wav2Vec2ConformerForCTC](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC).

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 [Wav2Vec2ConformerForSequenceClassification](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForSequenceClassification).

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`, *tuỳ 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 Wav2Vec2Conformer hay không. Điều này có thể rất hữu ích để khởi tạo nóng (warm-start) Wav2Vec2Conformer 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`.

position_embeddings_type (`str`, *tùy chọn*, mặc định là `"relative"`) : Có thể được chỉ định là `relative` hoặc `rotary` cho các vector nhúng vị trí tương đối hoặc quay tương ứng. Nếu để `None`, sẽ không áp dụng vector nhúng vị trí tương đối.

rotary_embedding_base (`int`, *optional*, mặc định là 10000) : Nếu sử dụng `"rotary"` position embeddings, định nghĩa kích thước của embedding base.

max_source_positions (`int`, *optional*, mặc định là 5000) : nếu sử dụng position embeddings `"relative"`, định nghĩa vị trí đầu vào nguồn tối đa.

conv_depthwise_kernel_size (`int`, *tuỳ chọn*, mặc định là 31) : Kích thước kernel của lớp 1D depthwise convolutional trong các khối Conformer.

conformer_conv_dropout (`float`, *optional*, mặc định là 0.1) : Xác suất dropout cho tất cả các lớp tích chập trong các khối Conformer.

Đây là lớp cấu hình để lưu trữ cấu hình của một Wav2Vec2 ConformerModel. Nó được sử dụng để khởi tạo một mô hình Wav2Vec2 Conformer 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-conformer-rel-pos-large](https://huggingface.co/facebook/wav2vec2-conformer-rel-pos-large)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import Wav2Vec2ConformerConfig, Wav2Vec2ConformerModel

>>> # Initializing a Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> configuration = Wav2Vec2ConformerConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> model = Wav2Vec2ConformerModel(configuration)

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

## Đầu ra cụ thể của Wav2Vec2Conformer[[transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput]]

#### transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput[[transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput]]

```python
transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput(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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L47)

**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 [Wav2Vec2ConformerForPreTraining](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForPreTraining), có thể bao gồm trạng thái ẩn và chú ý.

## Wav2Vec2ConformerModel[[transformers.Wav2Vec2ConformerModel]]

#### transformers.Wav2Vec2ConformerModel[[transformers.Wav2Vec2ConformerModel]]

```python
transformers.Wav2Vec2ConformerModel(config: Wav2Vec2ConformerConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1080)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Wav2Vec2 Conformer 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/v5.23.0/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.Wav2Vec2ConformerModel.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1151)

**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/v5.23.0/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/v5.23.0/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/v5.23.0/vi/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [Wav2Vec2BaseModelOutput](/docs/transformers/v5.23.0/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 ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerModel](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerModel) 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.

## Wav2Vec2ConformerForCTC[[transformers.Wav2Vec2ConformerForCTC]]

#### transformers.Wav2Vec2ConformerForCTC[[transformers.Wav2Vec2ConformerForCTC]]

```python
transformers.Wav2Vec2ConformerForCTC(config: Wav2Vec2ConformerConfig, target_lang: str | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1405)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/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 [UniSpeechSatForCTC](/docs/transformers/v5.23.0/vi/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) với adapters. Mặc định sử dụng 'eng'.

Mô hình Wav2Vec2Conformer 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/v5.23.0/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.Wav2Vec2ConformerForCTC.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1442)

**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/v5.23.0/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/v5.23.0/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/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.CausalLMOutput) hoặc `tuple(torch.Tensor)`

Một [CausalLMOutput](/docs/transformers/v5.23.0/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 phần tử khác nhau tùy thuộc vào cấu hình ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerForCTC](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC) 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, Wav2Vec2ConformerForCTC
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForCTC.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

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

## Wav2Vec2ConformerForSequenceClassification[[transformers.Wav2Vec2ConformerForSequenceClassification]]

#### transformers.Wav2Vec2ConformerForSequenceClassification[[transformers.Wav2Vec2ConformerForSequenceClassification]]

```python
transformers.Wav2Vec2ConformerForSequenceClassification(config: Wav2Vec2ConformerConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1500)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Wav2Vec2Conformer 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/v5.23.0/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.Wav2Vec2ConformerForSequenceClassification.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1533)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem `Wav2Vec2ConformerProcessor.__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/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) hoặc `tuple(torch.Tensor)`

Một [SequenceClassifierOutput](/docs/transformers/v5.23.0/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 thành phần khác nhau tùy thuộc vào cấu hình ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerForSequenceClassification](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForSequenceClassification) 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, Wav2Vec2ConformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> 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 = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", 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, Wav2Vec2ConformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", 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 = Wav2Vec2ConformerForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-conformer-rel-pos-large", 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
```

## Wav2Vec2ConformerForAudioFrameClassification[[transformers.Wav2Vec2ConformerForAudioFrameClassification]]

#### transformers.Wav2Vec2ConformerForAudioFrameClassification[[transformers.Wav2Vec2ConformerForAudioFrameClassification]]

```python
transformers.Wav2Vec2ConformerForAudioFrameClassification(config: Wav2Vec2ConformerConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1593)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Wav2Vec2 Conformer 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/v5.23.0/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.Wav2Vec2ConformerForAudioFrameClassification.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1625)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem `Wav2Vec2ConformerProcessor.__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/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) hoặc `tuple(torch.Tensor)`

Một [TokenClassifierOutput](/docs/transformers/v5.23.0/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 ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerForAudioFrameClassification](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForAudioFrameClassification) 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, Wav2Vec2ConformerForAudioFrameClassification
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForAudioFrameClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

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

## Wav2Vec2ConformerForXVector[[transformers.Wav2Vec2ConformerForXVector]]

#### transformers.Wav2Vec2ConformerForXVector[[transformers.Wav2Vec2ConformerForXVector]]

```python
transformers.Wav2Vec2ConformerForXVector(config: Wav2Vec2ConformerConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1741)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Wav2Vec2Conformer 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/v5.23.0/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.Wav2Vec2ConformerForXVector.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1791)

**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/v5.23.0/vi/model_doc/auto#transformers.AutoProcessor) để thực hiện padding và chuyển đổi thành tensor có kiểu `torch.Tensor`. Xem `Wav2Vec2ConformerProcessor.__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/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.XVectorOutput) hoặc `tuple(torch.Tensor)`

Một [XVectorOutput](/docs/transformers/v5.23.0/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 phần tử khác nhau tùy thuộc vào cấu hình ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerForXVector](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForXVector) 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, Wav2Vec2ConformerForXVector
>>> 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-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForXVector.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

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

## Wav2Vec2ConformerForPreTraining[[transformers.Wav2Vec2ConformerForPreTraining]]

#### transformers.Wav2Vec2ConformerForPreTraining[[transformers.Wav2Vec2ConformerForPreTraining]]

```python
transformers.Wav2Vec2ConformerForPreTraining(config: Wav2Vec2ConformerConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1202)

**Tham số:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Wav2Vec2Conformer với một 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/v5.23.0/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.Wav2Vec2ConformerForPreTraining.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/v5.23.0/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1250)

**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/v5.23.0/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/v5.23.0/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ề:** [Wav2Vec2ConformerForPreTrainingOutput](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput) hoặc `tuple(torch.Tensor)`

Một [Wav2Vec2ConformerForPreTrainingOutput](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput) 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 ([Wav2Vec2ConformerConfig](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2ConformerForPreTraining](/docs/transformers/v5.23.0/vi/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForPreTraining) 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, Wav2Vec2ConformerForPreTraining
>>> from transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2_conformer-base")
>>> model = Wav2Vec2ConformerForPreTraining.from_pretrained("facebook/wav2vec2_conformer-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
```

