# DPR

## Tổng quan

Dense Passage Retrieval (DPR) là một bộ công cụ và mô hình cho nghiên cứu hỏi đáp (Q&A) mở theo lĩnh vực tiên tiến nhất. Nó được giới thiệu trong [Dense Passage Retrieval for Open-Domain Question Answering](https://huggingface.co/papers/2004.04906) bởi Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih.

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

*Trả lời câu hỏi mở (open-domain question answering) dựa vào việc truy xuất đoạn văn bản hiệu quả để chọn các ngữ cảnh ứng viên, trong đó các mô hình không gian vector thưa truyền thống, chẳng hạn như TF-IDF hoặc BM25, là phương pháp mặc định. Trong công việc này, chúng tôi cho thấy rằng việc truy xuất có thể được triển khai thực tế chỉ bằng các biểu diễn đặc (dense), trong đó các embedding được học từ một số lượng nhỏ các câu hỏi và đoạn văn bản bằng một khung dual-encoder đơn giản. Khi được đánh giá trên một loạt các bộ dữ liệu QA mở, bộ truy xuất đặc của chúng tôi vượt trội so với hệ thống Lucene-BM25 mạnh, chủ yếu nhờ lợi thế 9%-19% tuyệt đối về độ chính xác truy xuất top-20 đoạn văn bản, và giúp hệ thống QA end-to-end của chúng tôi thiết lập mức state-of-the-art mới trên nhiều benchmark QA mở.*

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

## Mẹo sử dụng

- DPR bao gồm ba mô hình:

  * Bộ mã hóa câu hỏi: mã hóa các câu hỏi thành các vector
  * Bộ mã hóa ngữ cảnh: mã hóa các ngữ cảnh thành các vector
  * Reader: trích xuất câu trả lời cho các câu hỏi trong các ngữ cảnh đã truy xuất, kèm theo điểm số liên quan (cao nếu đoạn văn suy ra thực sự trả lời được câu hỏi).

## DPRConfig[[transformers.DPRConfig]]

#### transformers.DPRConfig[[transformers.DPRConfig]]

```python
transformers.DPRConfig(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 = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, projection_dim: int = 0, is_decoder: bool = False, add_cross_attention: bool = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/configuration_dpr.py#L24)

**Tham số:**

vocab_size (`int`, *tùy chọn*, mặc định là `30522`) : 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_prob (`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.

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

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `512`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng.

type_vocab_size (`int`, *tùy chọn*, mặc định là `2`) : Kích thước từ vựng của `token_type_ids`.

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-12`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

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`, *tùy chọn*) : Id của token được sử dụng cho đầu luồng trong bảng từ vựng.

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

projection_dim (`int`, *optional*, mặc định là `0`) : Độ chiều của các lớp chiếu văn bản và thị giác.

is_decoder (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem mô hình có được sử dụng như một bộ giải mã (decoder) hay không. Nếu `False`, mô hình sẽ được sử dụng như một bộ mã hóa (encoder).

add_cross_attention (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên thêm các lớp cross-attention vào mô hình hay không.

Đây là lớp cấu hình để lưu trữ cấu hình của một DPRQuestionEncoder. Nó được sử dụng để khởi tạo một mô hình Dpr theo các đối số được chỉ định, xác định kiến trúc 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ủa [facebook/dpr-ctx_encoder-single-nq-base](https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base)

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 DPRConfig, DPRContextEncoder

>>> # Initializing a DPR facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> configuration = DPRConfig()

>>> # Initializing a model (with random weights) from the facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> model = DPRContextEncoder(configuration)

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

## DPRContextEncoderTokenizer[[transformers.DPRContextEncoderTokenizer]]

#### transformers.DPRContextEncoderTokenizer[[transformers.DPRContextEncoderTokenizer]]

```python
transformers.DPRContextEncoderTokenizer(*args, do_lower_case = False, **kwargs)
```

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

Xây dựng bộ mã hóa (tokenizer) DPRContextEncoder.

[DPRContextEncoderTokenizer](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRContextEncoderTokenizer) giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece.

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

## DPRContextEncoderTokenizerFast[[transformers.DPRContextEncoderTokenizerFast]]

#### transformers.DPRContextEncoderTokenizerFast[[transformers.DPRContextEncoderTokenizerFast]]

```python
transformers.DPRContextEncoderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L29)

Tạo một tokenizer "fast" cho DPRContextEncoder (dựa trên thư viện *tokenizers* của HuggingFace).

[DPRContextEncoderTokenizerFast](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRContextEncoderTokenizerFast) giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece.

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

## DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

#### transformers.DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

```python
transformers.DPRQuestionEncoderTokenizer(*args, do_lower_case = False, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr.py#L45)

Tạo một tokenizer DPRQuestionEncoder.

[DPRQuestionEncoderTokenizer](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRQuestionEncoderTokenizer) giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece.

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

## DPRQuestionEncoderTokenizerFast[[transformers.DPRQuestionEncoderTokenizerFast]]

#### transformers.DPRQuestionEncoderTokenizerFast[[transformers.DPRQuestionEncoderTokenizerFast]]

```python
transformers.DPRQuestionEncoderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L43)

Tạo bộ mã hóa (tokenizer) DPRQuestionEncoder "nhanh" (dựa trên thư viện *tokenizers* của HuggingFace).

[DPRQuestionEncoderTokenizerFast](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRQuestionEncoderTokenizerFast) giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece.

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

## DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

#### transformers.DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

```python
transformers.DPRReaderTokenizer(*args, do_lower_case = False, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr.py#L311)

**Tham số:**

questions (`str` hoặc `list[str]`) : Các câu hỏi cần được mã hóa. Bạn có thể chỉ định một câu hỏi cho nhiều đoạn văn. Trong trường hợp này, câu hỏi sẽ được nhân bản như `[questions] * n_passages`. Ngược lại, bạn phải chỉ định số lượng câu hỏi bằng với số lượng trong `titles` hoặc `texts`.

titles (`str` hoặc `list[str]`) : Tiêu đề của các đoạn văn cần được mã hóa. Đây có thể là một chuỗi hoặc một danh sách các chuỗi nếu có nhiều đoạn văn.

texts (`str` hoặc `list[str]`) : Văn bản của các đoạn cần được mã hóa. Đây có thể là một chuỗi hoặc một danh sách các chuỗi nếu có nhiều đoạn.

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

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

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

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

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

**Trả về:** `dict[str, list[list[int]]]`

Một từ điển có các khóa sau:

- `input_ids`: Danh sách các id token để đưa vào mô hình.
- `attention_mask`: Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến.

Xây dựng một tokenizer DPRReader.

[DPRReaderTokenizer](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReaderTokenizer) gần như giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece. Điểm khác biệt là nó có ba chuỗi đầu vào: question, titles và texts, được kết hợp lại để đưa vào mô hình [DPRReader](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReader).

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

Trả về một từ điển chứa các token id của các chuỗi đầu vào cùng các thông tin khác để truyền cho `.decode_best_spans`. Hàm này chuyển đổi các chuỗi của một câu hỏi và các đoạn văn khác nhau (tiêu đề và nội dung) thành một dãy ID (số nguyên), sử dụng tokenizer và bảng từ vựng. Kết quả `input_ids` là một ma trận có kích thước `(n_passages, sequence_length)`

với định dạng:

```
[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>
```

## DPRReaderTokenizerFast[[transformers.DPRReaderTokenizerFast]]

#### transformers.DPRReaderTokenizerFast[[transformers.DPRReaderTokenizerFast]]

```python
transformers.DPRReaderTokenizerFast(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/tokenization_dpr_fast.py#L301)

**Tham số:**

questions (`str` hoặc `list[str]`) : Các câu hỏi cần được mã hóa. Bạn có thể chỉ định một câu hỏi cho nhiều đoạn văn. Trong trường hợp này, câu hỏi sẽ được nhân bản như `[questions] * n_passages`. Ngược lại, bạn phải chỉ định số lượng câu hỏi bằng với số lượng trong `titles` hoặc `texts`.

titles (`str` hoặc `list[str]`) : Tiêu đề của các đoạn văn cần được mã hóa. Đây có thể là một chuỗi hoặc một danh sách các chuỗi nếu có nhiều đoạn văn.

texts (`str` hoặc `list[str]`) : Văn bản của các đoạn cần được mã hóa. Đây có thể là một chuỗi hoặc một danh sách các chuỗi nếu có nhiều đoạn.

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

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

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

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

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

**Trả về:** `dict[str, list[list[int]]]`

Một từ điển có các khóa sau:

- `input_ids`: Danh sách các id token để đưa vào mô hình.
- `attention_mask`: Danh sách các chỉ số chỉ định những token nào nên được mô hình chú ý đến.

Tạo một tokenizer DPRReader "nhanh" (dựa trên thư viện *tokenizers* của HuggingFace).

[DPRReaderTokenizerFast](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReaderTokenizerFast) gần như giống hệt với [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) và thực hiện tokenization từ đầu đến cuối: tách dấu câu và wordpiece. Điểm khác biệt là nó có ba chuỗi đầu vào: question, titles và texts, được kết hợp lại để đưa vào mô hình [DPRReader](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReader).

Tham khảo siêu lớp [BertTokenizer](/docs/transformers/main/vi/model_doc/lxmert#transformers.BertTokenizer) để xem các ví dụ sử dụng và tài liệu liên quan đến các tham số.

Trả về một từ điển chứa các token id của các chuỗi đầu vào cùng các thông tin khác để truyền cho `.decode_best_spans`. Hàm này chuyển đổi các chuỗi của một câu hỏi và các đoạn văn bản khác nhau (tiêu đề và nội dung) thành một dãy ID (số nguyên), sử dụng tokenizer và bảng từ vựng. Kết quả `input_ids` là một ma trận có kích thước `(n_passages, sequence_length)` với định dạng:

[CLS] [SEP] [SEP]

## Đầu ra cụ thể của DPR[[transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput]]

#### transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput[[transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput]]

```python
transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput(pooler_output: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

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

**Tham số:**

pooler_output (`torch.Tensor` có shape `(batch_size, embeddings_size)`) : Bộ mã hóa DPR xuất ra *pooler_output* tương ứng với biểu diễn ngữ cảnh. Trạng thái ẩn của lớp cuối cùng của token đầu tiên trong chuỗi (token phân loại) được xử lý tiếp bởi một lớp Linear. Đầu ra này được dùng để nhúng ngữ cảnh cho các truy vấn láng giềng gần nhất với các embedding câu hỏi.

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

Lớp cho đầu ra của [DPRQuestionEncoder](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRQuestionEncoder).

#### transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput[[transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput]]

```python
transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput(pooler_output: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

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

**Tham số:**

pooler_output (`torch.Tensor` có shape `(batch_size, embeddings_size)`) : Bộ mã hóa DPR xuất ra *pooler_output* tương ứng với biểu diễn của câu hỏi. Trạng thái ẩn của lớp cuối cùng của token đầu tiên trong chuỗi (token phân loại) được xử lý tiếp bởi một lớp Linear. Đầu ra này được dùng để nhúng các câu hỏi cho các truy vấn láng giềng gần nhất với các embedding ngữ cảnh.

hidden_states (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings, 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).

Lớp cho đầu ra của [DPRQuestionEncoder](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRQuestionEncoder).

#### transformers.DPRReaderOutput[[transformers.DPRReaderOutput]]

```python
transformers.DPRReaderOutput(start_logits: Tensor, end_logits: typing.Optional[torch.Tensor] = None, relevance_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L84)

**Tham số:**

start_logits (`torch.Tensor` có hình dạng `(n_passages, sequence_length)`) : Logits của chỉ số bắt đầu của span cho mỗi passage.

end_logits (`torch.Tensor` có hình dạng `(n_passages, sequence_length)`) : Logits của chỉ số kết thúc của span cho mỗi passage.

relevance_logits (`torch.Tensor` có hình dạng `(n_passages, )`) : Đầu ra của bộ phân loại QA của DPRReader, tương ứng với điểm số của mỗi đoạn văn để trả lời câu hỏi, so với tất cả các đoạn văn khác.

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

Lớp cho đầu ra của [DPRQuestionEncoder](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRQuestionEncoder).

## DPRContextEncoder[[transformers.DPRContextEncoder]]

#### transformers.DPRContextEncoder[[transformers.DPRContextEncoder]]

```python
transformers.DPRContextEncoder(config: DPRConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L265)

**Tham số:**

config ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) : 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.

Transformer DPRContextEncoder cơ bản, xuất ra các đầu ra pooler dưới dạng các biểu diễn ngữ cảnh.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L273)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Để khớp với quá trình tiền huấn luyện, chuỗi đầu vào của DPR nên được định dạng với các token [CLS] và [SEP] như sau:  (a) Đối với các cặp chuỗi (ví dụ: một cặp tiêu đề + văn bản):

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)

token_type_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một [DPRContextEncoderOutput](/docs/transformers/main/vi/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) 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 ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) và đầu vào.

Phương thức forward của [DPRContextEncoder](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRContextEncoder) ghi đè 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.

- **pooler_output** (`torch.Tensor` có shape `(batch_size, embeddings_size)`) -- Bộ mã hóa DPR xuất ra *pooler_output* tương ứng với biểu diễn ngữ cảnh. Đây là trạng thái ẩn của lớp cuối cùng của token đầu tiên trong chuỗi (token phân loại), được xử lý thêm bởi một lớp Linear. Đầu ra này được dùng để nhúng ngữ cảnh cho các truy vấn láng giềng gần nhất với các embedding câu hỏi.
- **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`) -- 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, ...]`, *tùy 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.

```
tokens:         [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
```

  (b) Đối với các chuỗi đơn (ví dụ như một câu hỏi):

```
tokens:         [CLS] the dog is hairy . [SEP]
token_type_ids:   0   0   0   0  0     0   0
```

  DPR là một mô hình có nhúng vị trí tuyệt đối, vì vậy thường được khuyến nghị đệm đầu vào ở bên phải thay vì bên trái.

  Các chỉ số có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

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

Ví dụ:

```python
>>> from transformers import DPRContextEncoder, DPRContextEncoderTokenizer

>>> tokenizer = DPRContextEncoderTokenizer.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> model = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_output
```

## DPRQuestionEncoder[[transformers.DPRQuestionEncoder]]

#### transformers.DPRQuestionEncoder[[transformers.DPRQuestionEncoder]]

```python
transformers.DPRQuestionEncoder(config: DPRConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L371)

**Tham số:**

config ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) : 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.

Transformer DPRQuestionEncoder cơ bản, xuất ra các đầu ra pooler dưới dạng biểu diễn câu hỏ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.DPRQuestionEncoder.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L379)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Để khớp với quá trình tiền huấn luyện, chuỗi đầu vào của DPR nên được định dạng với các token [CLS] và [SEP] như sau:  (a) Đối với các cặp chuỗi (ví dụ: một cặp tiêu đề + văn bản):

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)

token_type_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một [DPRQuestionEncoderOutput](/docs/transformers/main/vi/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) 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 ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) và đầu vào.

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

- **pooler_output** (`torch.Tensor` có shape `(batch_size, embeddings_size)`) -- Bộ mã hóa DPR xuất ra *pooler_output* tương ứng với biểu diễn của câu hỏi. Đây là trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại), sau đó được xử lý thêm bởi một lớp Linear. Đầu ra này được dùng để nhúng các câu hỏi cho các truy vấn láng giềng gần nhất với các embedding ngữ cảnh.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- 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, ...]`, *tùy 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.

```
tokens:         [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
```

  (b) Đối với các chuỗi đơn (ví dụ như một câu hỏi):

```
tokens:         [CLS] the dog is hairy . [SEP]
token_type_ids:   0   0   0   0  0     0   0
```

  DPR là một mô hình có nhúng vị trí tuyệt đối, vì vậy thường được khuyến nghị đệm đầu vào ở bên phải thay vì bên trái.

  Các chỉ số có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết.

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

Ví dụ:

```python
>>> from transformers import DPRQuestionEncoder, DPRQuestionEncoderTokenizer

>>> tokenizer = DPRQuestionEncoderTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> model = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_output
```

## DPRReader[[transformers.DPRReader]]

#### transformers.DPRReader[[transformers.DPRReader]]

```python
transformers.DPRReader(config: DPRConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L478)

**Tham số:**

config ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) : 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.

Transformer DPRReader cơ bản, xuất ra các dự đoán span.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dpr/modeling_dpr.py#L486)

**Tham số:**

input_ids (`tuple[torch.LongTensor]` có hình dạng `(n_passages, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ điển. Nó phải là một bộ ba chuỗi gồm 1) câu hỏi và 2) tiêu đề các đoạn văn và 3) nội dung các đoạn văn. Để khớp với quá trình tiền huấn luyện, chuỗi `input_ids` của DPR phải được định dạng bằng [CLS] và [SEP] theo cấu trúc:  `[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>`  DPR là một mô hình có nhúng vị trí tuyệt đối, vì vậy thường được khuyến nghị đệm đầu vào bên phải thay vì bên trái.  Có thể lấy chỉ số bằng cách sử dụng [DPRReaderTokenizer](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReaderTokenizer). Xem tài liệu của lớp này để biết thêm chi tiết.  [input IDs là gì?](../glossary#input-ids)

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)

inputs_embeds (`torch.Tensor` có hình dạng `(n_passages, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một [DPRReaderOutput](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRReaderOutput) 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 ([DPRConfig](/docs/transformers/main/vi/model_doc/dpr#transformers.DPRConfig)) và đầu vào.

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

- **start_logits** (`torch.Tensor` có hình dạng `(n_passages, sequence_length)`) -- Logits của chỉ số bắt đầu của span cho mỗi passage.
- **end_logits** (`torch.Tensor` có hình dạng `(n_passages, sequence_length)`) -- Logits của chỉ số kết thúc của span cho mỗi passage.
- **relevance_logits** (`torch.Tensor` có hình dạng `(n_passages, )`) -- Đầu ra của bộ phân loại QA của DPRReader, tương ứng với điểm số của mỗi đoạn văn để trả lời câu hỏi, so với tất cả các đoạn văn khác.
- **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`) -- 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, ...]`, *tùy 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 DPRReader, DPRReaderTokenizer

>>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> model = DPRReader.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> encoded_inputs = tokenizer(
...     questions=["What is love ?"],
...     titles=["Haddaway"],
...     texts=["'What Is Love' is a song recorded by the artist Haddaway"],
...     return_tensors="pt",
... )
>>> outputs = model(**encoded_inputs)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> relevance_logits = outputs.relevance_logits
```