# DPR

## 概述

Dense Passage Retrieval (DPR) 是一套用于最先进开放域问答研究的工具和模型。它由 Vladimir Karpukhin、Barlas Oğuz、Sewon Min、Patrick Lewis、Ledell Wu、Sergey Edunov、Danqi Chen 和 Wen-tau Yih 在 [Dense Passage Retrieval for Open-Domain Question Answering](https://huggingface.co/papers/2004.04906) 中提出。

该论文的摘要如下：

*开放域问答依赖于高效的段落检索来选择候选上下文，其中传统的稀疏向量空间模型（如 TF-IDF 或 BM25）是事实上的标准方法。在本工作中，我们表明仅使用稠密表示即可实际实现检索，其中嵌入是通过一个简单的双编码器框架从少量问题和段落中学习得到的。在广泛的开放域 QA 数据集上进行评估时，我们的稠密检索器在 top-20 段落检索准确率方面，以 9%-19% 的绝对优势大幅超越了强大的 Lucene-BM25 系统，并帮助我们的端到端 QA 系统在多个开放域 QA 基准上建立了新的最先进水平。*

该模型由 [lhoestq](https://huggingface.co/lhoestq) 贡献。原始代码可在[此处](https://github.com/facebookresearch/DPR)找到。

## 使用技巧

- DPR 由三个模型组成：

  * 问题编码器：将问题编码为向量
  * 上下文编码器：将上下文编码为向量
  * Reader：从检索到的上下文中提取问题的答案，并附带一个相关性分数（如果推断出的片段确实回答了问题，则分数较高）。

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

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

**参数：**

vocab_size (`int`，*可选*，默认值为 `30522`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：注意力概率的 dropout 比率。

max_position_embeddings (`int`，*可选*，默认值为 `512`)：该模型可能使用的最大序列长度。

type_vocab_size (`int`，*可选*，默认为 `2`)：`token_type_ids` 的词汇表大小。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。

bos_token_id (`int`, *可选*) : 词表中用于表示流开始的 Token id。

eos_token_id (`Union[int, list[int]]`，*可选*)：词汇表中用于表示流结束（end-of-stream）的 Token ID。

projection_dim (`int`, *可选*, 默认为 `0`) : 文本和视觉投影层的维度。

is_decoder (`bool`，*可选*，默认为 `False`)：模型是否用作解码器。如果为 `False`，则模型用作编码器。

add_cross_attention (`bool`，*可选*，默认为 `False`)：是否应在模型中添加交叉注意力层。

这是用于存储 DPRQuestionEncoder 配置的类。它根据指定的参数实例化 Dpr 模型，并定义模型架构。使用默认值实例化配置将得到与 [facebook/dpr-ctx_encoder-single-nq-base](https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

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

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

构建 DPRContextEncoder 分词器。

[DPRContextEncoderTokenizer](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRContextEncoderTokenizer) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 完全相同，并执行端到端的分词：标点拆分和 wordpiece。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

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

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

构建一个“快速”的 DPRContextEncoder 分词器（由 HuggingFace 的 *tokenizers* 库提供支持）。

[DPRContextEncoderTokenizerFast](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRContextEncoderTokenizerFast) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 完全相同，并执行端到端的分词：标点拆分和 wordpiece。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

## DPRQuestionEncoderTokenizer[[transformers.DPRQuestionEncoderTokenizer]]

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

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

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

构建 DPRQuestionEncoder 分词器。

[DPRQuestionEncoderTokenizer](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRQuestionEncoderTokenizer) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 完全相同，并执行端到端的分词：标点拆分和 wordpiece。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

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

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

构建一个“快速”的 DPRQuestionEncoder 分词器（由 HuggingFace 的 *tokenizers* 库提供支持）。

[DPRQuestionEncoderTokenizerFast](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRQuestionEncoderTokenizerFast) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 完全相同，并执行端到端的分词：标点拆分和 wordpiece。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

## DPRReaderTokenizer[[transformers.DPRReaderTokenizer]]

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

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

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

**参数：**

questions (`str` 或 `list[str]`) : 要编码的问题。您可以为多个段落指定一个问题。在这种情况下，问题将像 `[questions] * n_passages` 一样被重复。否则，您必须指定与 `titles` 或 `texts` 中相同数量的问题。

titles (`str` 或 `list[str]`) : 要编码的段落标题。如果存在多个段落，则可以是字符串或字符串列表。

texts (`str` 或 `list[str]`) : 要编码的段落文本。如果存在多个段落，则可以是字符串或字符串列表。

padding (`bool`、`str` 或 [PaddingStrategy](/docs/transformers/main/zh/internal/file_utils#transformers.utils.PaddingStrategy)，*可选*，默认为 `False`)：启用并控制填充。接受以下值： - `True` 或 `'longest'`：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。 - `'max_length'`：填充至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则填充至模型可接受的最大输入长度。 - `False` 或 `'do_not_pad'`（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。

truncation (`bool`、`str` 或 [TruncationStrategy](/docs/transformers/main/zh/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)，*optional*，默认为 `False`)：启用并控制截断。接受以下值： - `True` 或 `'longest_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将逐个 token 进行截断，从该对中最长的序列中移除一个 token。 - `'only_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第一个序列。 - `'only_second'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第二个序列。 - `False` 或 `'do_not_truncate'`（默认）：不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。

max_length (`int`, *可选*) : 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 `None`，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。

return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。

return_attention_mask (`bool`, *可选*) : 是否返回注意力掩码。如果未设置，将根据特定分词器的默认值返回注意力掩码，该默认值由 `return_outputs` 属性定义。  [什么是注意力掩码？](../glossary#attention-mask)

**返回：** `dict[str, list[list[int]]]`

一个包含以下键的字典：

- `input_ids`：要输入模型的 token id 列表。
- `attention_mask`：一个索引列表，指定模型应关注哪些 token。

构建 DPRReader 分词器。

[DPRReaderTokenizer](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReaderTokenizer) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 几乎完全相同，并执行端到端的分词：标点符号拆分和 wordpiece。区别在于它有三个输入字符串：question、titles 和 texts，它们会被组合起来并输入到 [DPRReader](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReader) 模型中。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

返回一个字典，其中包含输入字符串的 token id 以及传递给 `.decode_best_spans` 所需的其他信息。它使用分词器和词汇表，将问题和不同段落（标题和正文）的字符串转换为 ID（整数）序列。生成的 `input_ids` 是一个大小为 `(n_passages, sequence_length)` 的矩阵

格式如下：

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

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

**参数：**

questions (`str` 或 `list[str]`) : 要编码的问题。您可以为多个段落指定一个问题。在这种情况下，问题将像 `[questions] * n_passages` 一样被重复。否则，您必须指定与 `titles` 或 `texts` 中相同数量的问题。

titles (`str` 或 `list[str]`) : 要编码的段落标题。如果存在多个段落，则可以是字符串或字符串列表。

texts (`str` 或 `list[str]`) : 要编码的段落文本。如果存在多个段落，则可以是字符串或字符串列表。

padding (`bool`、`str` 或 [PaddingStrategy](/docs/transformers/main/zh/internal/file_utils#transformers.utils.PaddingStrategy)，*可选*，默认为 `False`)：启用并控制填充。接受以下值： - `True` 或 `'longest'`：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。 - `'max_length'`：填充至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则填充至模型可接受的最大输入长度。 - `False` 或 `'do_not_pad'`（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。

truncation (`bool`、`str` 或 [TruncationStrategy](/docs/transformers/main/zh/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)，*optional*，默认为 `False`)：启用并控制截断。接受以下值： - `True` 或 `'longest_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将逐个 token 进行截断，从该对中最长的序列中移除一个 token。 - `'only_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第一个序列。 - `'only_second'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第二个序列。 - `False` 或 `'do_not_truncate'`（默认）：不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。

max_length (`int`, *可选*) : 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 `None`，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。

return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。

return_attention_mask (`bool`, *可选*) : 是否返回注意力掩码。如果未设置，将根据特定分词器的默认值返回注意力掩码，该默认值由 `return_outputs` 属性定义。  [什么是注意力掩码？](../glossary#attention-mask)

**返回：** `dict[str, list[list[int]]]`

一个包含以下键的字典：

- `input_ids`：要输入模型的 token id 列表。
- `attention_mask`：一个索引列表，指定模型应关注哪些 token。

构建一个“快速”的 DPRReader 分词器（由 HuggingFace 的 *tokenizers* 库提供支持）。

[DPRReaderTokenizerFast](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReaderTokenizerFast) 与 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer) 几乎完全相同，并执行端到端的分词：标点符号拆分和 wordpiece。区别在于它有三个输入字符串：question、titles 和 texts，它们会被组合起来并输入到 [DPRReader](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReader) 模型中。

有关参数用法示例和文档，请参阅父类 [BertTokenizer](/docs/transformers/main/zh/model_doc/lxmert#transformers.BertTokenizer)。

返回一个字典，其中包含输入字符串的 token id 以及传递给 `.decode_best_spans` 所需的其他信息。它使用分词器和词汇表，将问题和不同段落（标题和正文）的字符串转换为 ID（整数）序列。生成的 `input_ids` 是一个大小为 `(n_passages, sequence_length)` 的矩阵，其格式为：

[CLS]  [SEP]  [SEP]

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

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

**参数：**

pooler_output (`torch.Tensor`，形状为 `(batch_size, embeddings_size)`)：DPR 编码器输出与上下文表示相对应的 *pooler_output*。它是序列中第一个 token（分类 token）的最后一层隐藏状态，并经过一个 Linear 层进一步处理。该输出用于嵌入上下文，以便使用问题嵌入进行最近邻查询。

hidden_states (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

attentions (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

[DPRQuestionEncoder](/docs/transformers/main/zh/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)
```

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

**参数：**

pooler_output (`torch.Tensor`，形状为 `(batch_size, embeddings_size)`)：DPR 编码器输出与问题表示相对应的 *pooler_output*。它是序列中第一个 token（分类 token）的最后一层隐藏状态，并经过一个 Linear 层进一步处理。该输出用于嵌入问题，以便与上下文嵌入进行最近邻查询。

hidden_states (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

attentions (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

[DPRQuestionEncoder](/docs/transformers/main/zh/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)
```

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

**参数：**

start_logits (`torch.Tensor`，形状为 `(n_passages, sequence_length)`)：每个段落中片段起始索引的 Logits。

end_logits (`torch.Tensor`，形状为 `(n_passages, sequence_length)`)：每个 passage 的 span 结束索引的 logits。

relevance_logits (`torch.Tensor`，形状为 `(n_passages, )`)：DPRReader 中 QA 分类器的输出，对应于每个段落回答该问题的得分，与其他所有段落相比。

hidden_states (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

attentions (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

[DPRQuestionEncoder](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRQuestionEncoder) 的输出类。

## DPRContextEncoder[[transformers.DPRContextEncoder]]

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

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

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

**参数：**

config ([DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

输出池化器输出作为上下文表示的裸 DPRContextEncoder 转换器。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`)：输入序列中词元在词汇表中的索引。为了与预训练保持一致，DPR 输入序列应使用 [CLS] 和 [SEP] 词元按以下格式进行格式化： (a) 对于序列对（例如标题+文本对）：

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引取自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [DPRContextEncoderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) 或 `tuple(torch.Tensor)`

一个 [DPRContextEncoderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig)）和输入。

[DPRContextEncoder](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRContextEncoder) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **pooler_output**（形状为 `(batch_size, embeddings_size)` 的 `torch.Tensor`）-- DPR 编码器输出与上下文表示相对应的 *pooler_output*。它是序列中第一个 token（分类 token）的最后一层隐藏状态，并经过一个 Linear 层进一步处理。此输出用于嵌入上下文，以便使用问题嵌入进行最近邻查询。
- **hidden_states** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

  ```
  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) 对于单个序列（例如一个问题）：

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

  DPR 是一个使用绝对位置嵌入的模型，因此通常建议在右侧而非左侧填充输入。

  可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。

  [什么是输入 ID？](../glossary#input-ids)

示例：

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

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

**参数：**

config ([DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

原始的 DPRQuestionEncoder 转换器，其池化器输出作为问题表示。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`)：输入序列中词元在词汇表中的索引。为了与预训练保持一致，DPR 输入序列应使用 [CLS] 和 [SEP] 词元按以下格式进行格式化： (a) 对于序列对（例如标题+文本对）：

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引取自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [DPRQuestionEncoderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) 或 `tuple(torch.Tensor)`

一个 [DPRQuestionEncoderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig)）和输入。

[DPRQuestionEncoder](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRQuestionEncoder) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **pooler_output**（形状为 `(batch_size, embeddings_size)` 的 `torch.Tensor`）-- DPR 编码器输出与问题表示相对应的 *pooler_output*。它是序列中第一个 token（分类 token）的最后一层隐藏状态，并经过一个 Linear 层进一步处理。此输出用于嵌入问题，以便与上下文嵌入进行最近邻查询。
- **hidden_states** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

  ```
  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) 对于单个序列（例如一个问题）：

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

  DPR 是一个使用绝对位置嵌入的模型，因此通常建议在右侧而非左侧填充输入。

  可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。

  [什么是输入 ID？](../glossary#input-ids)

示例：

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

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

**参数：**

config ([DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

输出跨度预测的裸 DPRReader 转换器。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`tuple[torch.LongTensor]`，形状为 `(n_passages, sequence_length)`) : 输入序列标记在词汇表中的索引。它必须是一个序列三元组，包含 1) 问题、2) 段落标题和 3) 段落文本。为了与预训练保持一致，DPR 的 `input_ids` 序列应使用 [CLS] 和 [SEP] 进行格式化，格式如下：  `[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>`  DPR 是一个使用绝对位置嵌入的模型，因此通常建议在右侧而非左侧填充输入。  可以使用 [DPRReaderTokenizer](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReaderTokenizer) 获取索引。有关更多详细信息，请参阅该类的文档。  [什么是输入 ID？](../glossary#input-ids)

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

inputs_embeds (`torch.Tensor`，形状为 `(n_passages, sequence_length, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果您希望对如何将 `input_ids` 索引转换为对应的向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [DPRReaderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReaderOutput) 或 `tuple(torch.Tensor)`

一个 [DPRReaderOutput](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReaderOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[DPRConfig](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRConfig)）和输入。

[DPRReader](/docs/transformers/main/zh/model_doc/dpr#transformers.DPRReader) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **start_logits**（形状为 `(n_passages, sequence_length)` 的 `torch.Tensor`）-- 每个段落中片段起始索引的 logits。
- **end_logits**（形状为 `(n_passages, sequence_length)` 的 `torch.Tensor`）-- 每个段落中跨度结束位置的 logits。
- **relevance_logits**（形状为 `(n_passages, )` 的 `torch.Tensor`）-- DPRReader 中 QA 分类器的输出，对应于每个段落回答该问题的得分，与其他所有段落相比。
- **hidden_states** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

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

