# Wav2Vec2-BERT

## Tổng quan

Mô hình [Wav2Vec2-BERT](https://huggingface.co/papers/2312.05187) được đề xuất trong [Seamless: Multilingual Expressive and Streaming Speech Translation](https://ai.meta.com/research/publications/seamless-multilingual-expressive-and-streaming-speech-translation/) bởi nhóm Seamless Communication từ Meta AI.

Mô hình này được huấn luyện trước trên 4,5 triệu giờ dữ liệu âm thanh không nhãn, bao phủ hơn 143 ngôn ngữ. Nó cần được tinh chỉnh để sử dụng cho các tác vụ hạ nguồn như Nhận dạng giọng nói tự động (ASR) hoặc Phân loại âm thanh.

Kết quả chính thức của mô hình có thể được tìm thấy trong Mục 3.2.1 của bài báo.

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

*Những tiến bộ gần đây trong dịch thuật giọng nói tự động đã mở rộng đáng kể phạm vi ngôn ngữ, cải thiện khả năng đa phương thức và cho phép thực hiện nhiều tác vụ cũng như tính năng đa dạng. Tuy nhiên, so với hội thoại giữa người với người, các hệ thống dịch thuật giọng nói tự động quy mô lớn hiện nay vẫn thiếu những tính năng then chốt giúp giao tiếp qua máy móc trở nên liền mạch. Trong công trình này, chúng tôi giới thiệu một họ các mô hình cho phép dịch thuật đa ngôn ngữ và giàu cảm xúc theo phương thức streaming từ đầu đến cuối. Trước tiên, chúng tôi đóng góp một phiên bản cải tiến của mô hình đa ngôn ngữ và đa phương thức quy mô lớn SeamlessM4T—SeamlessM4T v2. Mô hình mới hơn này, tích hợp khung UnitY2 được cập nhật, đã được huấn luyện trên nhiều dữ liệu ngôn ngữ nguồn thấp hơn. Phiên bản mở rộng của SeamlessAlign bổ sung 114.800 giờ dữ liệu được căn chỉnh tự động, nâng tổng số lên 76 ngôn ngữ. SeamlessM4T v2 cung cấp nền tảng để khởi tạo hai mô hình mới nhất của chúng tôi: SeamlessExpressive và SeamlessStreaming. SeamlessExpressive cho phép dịch thuật bảo toàn phong cách giọng nói và ngữ điệu. So với các nỗ lực trước đây trong nghiên cứu giọng nói giàu cảm xúc, công trình của chúng tôi giải quyết một số khía cạnh của ngữ điệu chưa được khám phá nhiều, chẳng hạn như tốc độ nói và các khoảng dừng, đồng thời bảo toàn phong cách giọng nói của người nói. Về SeamlessStreaming, mô hình của chúng tôi tận dụng cơ chế Efficient Monotonic Multihead Attention (EMMA) để tạo ra bản dịch đích có độ trễ thấp mà không cần chờ câu nguồn hoàn chỉnh. Là mô hình đầu tiên thuộc loại này, SeamlessStreaming cho phép dịch đồng thời giọng nói sang giọng nói/văn bản cho nhiều ngôn ngữ nguồn và đích. Để đánh giá hiệu suất của các mô hình này, chúng tôi kết hợp các chỉ số tự động mới và các phiên bản sửa đổi của các chỉ số hiện có để đánh giá ngữ điệu, độ trễ và độ bền vững. Đối với đánh giá của con người, chúng tôi điều chỉnh các giao thức hiện có để đo lường các thuộc tính liên quan nhất trong việc bảo toàn ý nghĩa, tính tự nhiên và tính biểu cảm. Để đảm bảo các mô hình của chúng tôi có thể được sử dụng một cách an toàn và có trách nhiệm, chúng tôi đã triển khai nỗ lực red-teaming đầu tiên được biết đến cho dịch thuật máy đa phương thức, một hệ thống phát hiện và giảm thiểu độc tính được thêm vào, một đánh giá có hệ thống về thiên kiến giới tính, và một cơ chế đánh dấu nước địa phương không thể nghe thấy được thiết kế để làm giảm tác động của deepfake. Do đó, chúng tôi kết hợp các thành phần chính từ SeamlessExpressive và SeamlessStreaming để tạo thành Seamless, hệ thống công khai đầu tiên mở ra giao tiếp đa ngôn ngữ giàu cảm xúc theo thời gian thực. Tóm lại, Seamless mang đến cho chúng tôi cái nhìn then chốt về nền tảng kỹ thuật cần thiết để biến Universal Speech Translator từ một khái niệm khoa học viễn tưởng thành công nghệ thực tế. Cuối cùng, các đóng góp trong công trình này—including mô hình, mã nguồn và trình phát hiện đánh dấu nước—được công bố công khai và có thể truy cập tại liên kết bên dưới.*

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

## Mẹo sử dụng

- Wav2Vec2-BERT tuân theo cùng kiến trúc như Wav2Vec2-Conformer, nhưng sử dụng một lớp tích chập chiều sâu nhân quả và dùng làm đầu vào một biểu diễn mel-spectrogram của âm thanh thay vì dạng sóng thô.
- Wav2Vec2-BERT có thể sử dụng một trong các loại sau: không dùng position embeddings, position embeddings kiểu Shaw, position embeddings kiểu Transformer-XL, hoặc rotary position embeddings, bằng cách đặt giá trị đúng cho `config.position_embeddings_type`.
- Wav2Vec2-BERT cũng giới thiệu một mạng adapter dựa trên Conformer thay vì một mạng tích chập đơn giản.

## Tài nguyên

- Bạn cũng có thể điều chỉnh các notebook này 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).

- Xem thêm: [Hướng dẫn tác vụ phân loại âm thanh](../tasks/audio_classification)

## Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

#### transformers.Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

```python
transformers.Wav2Vec2BertConfig(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 = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, feature_projection_input_dim: int = 160, hidden_act: str = 'swish', hidden_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, attention_dropout: float | int = 0.0, feat_proj_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, 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, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 768, 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 = 1, adapter_act: str = 'relu', use_intermediate_ffn_before_adapter: bool = False, output_hidden_size: int | None = None, position_embeddings_type: typing.Optional[typing.Literal['rotary', 'relative', 'relative_key']] = 'relative_key', rotary_embedding_base: int = 10000, max_source_positions: int = 5000, left_max_position_embeddings: int = 64, right_max_position_embeddings: int = 8, conv_depthwise_kernel_size: int = 31, conformer_conv_dropout: float | int = 0.1)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/configuration_wav2vec2_bert.py#L26)

**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`, *tuỳ chọn*, mặc định là `1024`) : Kích thước của các biểu diễn ẩn.

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

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `16`) : 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à `4096`) : Kích thước của các biểu diễn MLP.

feature_projection_input_dim (`int`, *tuỳ chọn*, mặc định là 160) : Kích thước đầu vào của mô hình này, tức là kích thước sau khi xử lý âm thanh đầu vào bằng [SeamlessM4TFeatureExtractor](/docs/transformers/main/vi/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) hoặc [Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor).

hidden_act (`str`, *tùy chọn*, mặc định là `swish`) : 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.0`) : 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.0`) : 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.0`) : Tỷ lệ dropout cho các xác suất chú ý.

feat_proj_dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Xác suất dropout cho phép chiếu đặc trưng.

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 [Wav2Vec2BertForCTC](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC).

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

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*, defaults to 0.05) : Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates `mask_time_prob*len(time_axis)/mask_time_length ``independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, *mask_time_prob* should be `prob_vector_start*mask_time_length`. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if `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 mặt nạ 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) : Tỷ lệ (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 tỷ lệ 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_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`.

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 [Wav2Vec2BertForCTC](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC).

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 [Wav2Vec2BertForSequenceClassification](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForSequenceClassification).

classifier_proj_size (`int`, *optional*, mặc định là 768) : Độ 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 có nên xếp chồng một mạng chú ý tích chập lên trên Encoder của Wav2Vec2Bert hay không. Điều này có thể rất hữu ích để khởi động nóng Wav2Vec2Bert 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à 1) : 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`.

adapter_act (`str` hoặc `function`, *không bắt buộc*, mặc định là `"relu"`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong các lớp adapter. Nếu là chuỗi, `"gelu"`, `"relu"`, `"selu"`, `"swish"` và `"gelu_new"` được hỗ trợ.

use_intermediate_ffn_before_adapter (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên xếp chồng một khối feed-forward trung gian lên trên Encoder của Wav2Vec2Bert và đặt trước mạng adapter hay không. 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_key"`) : Có thể được chỉ định để : - `rotary`, cho các nhúng vị trí quay. - `relative`, cho các nhúng vị trí tương đối. - `relative_key`, cho các nhúng vị trí tương đối như được định nghĩa bởi Shaw trong [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155). Nếu để là `None`, sẽ không áp dụng 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.

left_max_position_embeddings (`int`, *optional*, mặc định là 64) : Nếu sử dụng position embeddings `"relative_key"` (còn gọi là Shaw), định nghĩa giá trị cắt trái cho các vị trí tương đối.

right_max_position_embeddings (`int`, *optional*, mặc định là 8) : Nếu sử dụng position embeddings `"relative_key"` (còn gọi là Shaw), định nghĩa giá trị cắt phía bên phải cho các vị trí tương đối.

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 BertModel. Nó được sử dụng để khởi tạo một mô hình Wav2Vec2 Bert 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/w2v-bert-2.0](https://huggingface.co/facebook/w2v-bert-2.0)

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 Wav2Vec2BertConfig, Wav2Vec2BertModel

>>> # Initializing a Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large style configuration
>>> configuration = Wav2Vec2BertConfig()

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

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

## Wav2Vec2BertProcessor[[transformers.Wav2Vec2BertProcessor]]

#### transformers.Wav2Vec2BertProcessor[[transformers.Wav2Vec2BertProcessor]]

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.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 Wav2Vec2BertProcessor đó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.

[Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) 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.Wav2Vec2BertProcessor.__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_bert.processing_wav2vec2_bert.Wav2Vec2BertProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.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ề:** [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_features** -- Các đặc trưng đầu vào âm thanh để đưa vào mô hình. Được trả về khi `audio` không phải `None`.
- **attention_mask** -- Danh sách các chỉ số chỉ định những mốc thời gian nào mà mô hình cần chú ý khi `audio` không phải là `None`.
Khi chỉ có `text` được chỉ định, hàm trả về mặt nạ chú ý (attention mask) của token.
- **labels** -- Danh sách các token id để đưa vào mô hình. Được trả về khi cả `text` và `audio` đều không phải `None`.
- **input_ids** -- Danh sách các token id để đưa vào mô hình. Được trả về khi `text` không phải `None` và `audio` là `None`.

#### pad[[transformers.Wav2Vec2BertProcessor.pad]]

```python
pad(input_features = None, labels = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L70)

Nếu `input_features` không phải là `None`, phương thức này sẽ chuyển các đối số `input_features` và `kwargs` đến [pad()](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) của SeamlessM4TFeatureExtractor để đệm các đặc trưng đầu vào. Nếu `labels` không phải là `None`, phương thức này sẽ chuyển các đối số `labels` và `kwargs` đến [pad()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) của PreTrainedTokenizer để đệm nhãn. Vui lòng tham khảo docstring của hai phương thức trên để biết thêm thông tin.

#### from_pretrained[[transformers.Wav2Vec2BertProcessor.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.Wav2Vec2BertProcessor.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.Wav2Vec2BertProcessor.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.Wav2Vec2BertProcessor.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.

## Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

#### transformers.Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

```python
transformers.Wav2Vec2BertModel(config: Wav2Vec2BertConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L940)

**Tham số:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) : 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 Bert 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.Wav2Vec2BertModel.forward]]

```python
forward(input_features: 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_bert/modeling_wav2vec2_bert.py#L1007)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Xem [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) để biết thêm chi tiết ([Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) để xử lý âm thanh).

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 ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) và đầu vào.

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

## Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

#### transformers.Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

```python
transformers.Wav2Vec2BertForCTC(config: Wav2Vec2BertConfig, target_lang: str | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1053)

**Tham số:**

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

Mô hình Wav2Vec2Bert 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.Wav2Vec2BertForCTC.forward]]

```python
forward(input_features: 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_bert/modeling_wav2vec2_bert.py#L1083)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Xem [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) để biết thêm chi tiết ([Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) để xử lý âm thanh).

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 ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2BertForCTC](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC) 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, Wav2Vec2BertForCTC
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForCTC.from_pretrained("facebook/w2v-bert-2.0")

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

## Wav2Vec2BertForSequenceClassification[[transformers.Wav2Vec2BertForSequenceClassification]]

#### transformers.Wav2Vec2BertForSequenceClassification[[transformers.Wav2Vec2BertForSequenceClassification]]

```python
transformers.Wav2Vec2BertForSequenceClassification(config: Wav2Vec2BertConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1143)

**Tham số:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) : 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 Wav2Vec2Bert 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.Wav2Vec2BertForSequenceClassification.forward]]

```python
forward(input_features: 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_bert/modeling_wav2vec2_bert.py#L1169)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Xem [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) để biết thêm chi tiết ([Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) để xử lý âm thanh).

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 ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) và đầu vào.

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0")

>>> 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 = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", 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, Wav2Vec2BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", 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 = Wav2Vec2BertForSequenceClassification.from_pretrained(
...     "facebook/w2v-bert-2.0", 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
```

## Wav2Vec2BertForAudioFrameClassification[[transformers.Wav2Vec2BertForAudioFrameClassification]]

#### transformers.Wav2Vec2BertForAudioFrameClassification[[transformers.Wav2Vec2BertForAudioFrameClassification]]

```python
transformers.Wav2Vec2BertForAudioFrameClassification(config: Wav2Vec2BertConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1227)

**Tham số:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) : 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 Bert với một đầu phân loại khung (frame classification head) ở trên cùng cho các tác vụ như Phân tách người nói (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.Wav2Vec2BertForAudioFrameClassification.forward]]

```python
forward(input_features: 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_bert/modeling_wav2vec2_bert.py#L1252)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Xem [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) để biết thêm chi tiết ([Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) để xử lý âm thanh).

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 ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2BertForAudioFrameClassification](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForAudioFrameClassification) 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, Wav2Vec2BertForAudioFrameClassification
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForAudioFrameClassification.from_pretrained("facebook/w2v-bert-2.0")

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

## Wav2Vec2BertForXVector[[transformers.Wav2Vec2BertForXVector]]

#### transformers.Wav2Vec2BertForXVector[[transformers.Wav2Vec2BertForXVector]]

```python
transformers.Wav2Vec2BertForXVector(config: Wav2Vec2BertConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1360)

**Tham số:**

config ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) : 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 Wav2Vec2Bert với đầu trích xuất đặc trưng XVector ở trên cùng 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.Wav2Vec2BertForXVector.forward]]

```python
forward(input_features: 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_bert/modeling_wav2vec2_bert.py#L1403)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Xem [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) để biết thêm chi tiết ([Wav2Vec2BertProcessor](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) sử dụng [Wav2Vec2FeatureExtractor](/docs/transformers/main/vi/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) để xử lý âm thanh).

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 ([Wav2Vec2BertConfig](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) và đầu vào.

Phương thức forward của [Wav2Vec2BertForXVector](/docs/transformers/main/vi/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForXVector) 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, Wav2Vec2BertForXVector
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForXVector.from_pretrained("facebook/w2v-bert-2.0")

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