Hugging Face 的 LOGO

Transformers 文档

DPR

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

此模型于 2020-04-10 发布，并于 2020-11-16 添加到 Hugging Face Transformers。

DPR

PyTorch SDPA

概述

密集段落检索 (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 中介绍。

论文摘要如下：

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

此模型由 lhoestq 贡献。原始代码可以在 这里找到。

使用技巧

  • DPR 包含三个模型

    • 问题编码器：将问题编码为向量
    • 上下文编码器：将上下文编码为向量
    • 阅读器：从检索到的上下文中提取问题的答案，以及一个相关性分数（如果推断出的跨度确实回答了问题，则分数较高）。

DPRConfig

class transformers.DPRConfig

< >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 bos_token_id = None eos_token_id = None projection_dim: int = 0 is_decoder = False add_cross_attention = False **kwargs )

参数

  • vocab_size (int, optional, 默认为 30522) — DPR 模型的词汇表大小。定义了传递给 BertModel 前向方法的 inputs_ids 可以表示的不同标记。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数。
  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的大小。
  • hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。
  • hidden_dropout_prob (float, optional, 默认为 0.1) — 所有全连接层（嵌入层、编码器和池化层）的 dropout 概率。
  • attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能永远使用的最大序列长度。通常将其设置得稍大一些（例如 512、1024 或 2048）。
  • type_vocab_size (int, optional, 默认为 2) — 传递给 BertModel 的 token_type_ids 的词汇表大小。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
  • pad_token_id (int, optional, 默认为 0) — 填充标记 ID。
  • bos_token_id (int, optional) — 流开始标记 ID。
  • eos_token_id (int, optional) — 流结束标记 ID。
  • projection_dim (int, optional, 默认为 0) — 上下文和问题编码器的投影维度。如果设置为零（默认值），则不进行投影。
  • is_decoder (bool, optional, 默认为 False) — 是否仅在编解码器-解码器架构中使用解码器，否则它对仅解码器或仅编码器架构没有影响。
  • add_cross_attention (bool, optional, 默认为 False) — 是否在模型中添加交叉注意力层。

DPRConfig 是用于存储 DPRModel 配置的配置类。

这是用于存储 DPRContextEncoder, DPRQuestionEncoder 或 DPRReader 配置的配置类。它用于根据指定的参数实例化 DPR 模型的组件，定义模型组件的架构。使用默认值实例化一个配置将产生与 DPRContextEncoder facebook/dpr-ctx_encoder-single-nq-base 架构相似的配置。

此类是 BertConfig 的子类。请查看超类以获取所有 kwargs 的文档。

示例

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

class transformers.DPRContextEncoderTokenizer

< >

( *args do_lower_case = False **kwargs )

构建一个 DPRContextEncoder 分词器。

DPRContextEncoderTokenizer 与 BertTokenizer 完全相同，并执行端到端的标记化：标点符号分割和词元（wordpiece）。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

DPRContextEncoderTokenizerFast

class transformers.DPRContextEncoderTokenizerFast

< >

( vocab: str | dict[str, int] | None = None do_lower_case: bool = False 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 )

构建一个“快速”的 DPRContextEncoder 分词器（基于 HuggingFace 的 tokenizers 库）。

DPRContextEncoderTokenizerFast 与 BertTokenizer 完全相同，并实现了端到端的词法分析：标点符号分割和 wordpiece 分词。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

DPRQuestionEncoderTokenizer

class transformers.DPRQuestionEncoderTokenizer

< >

( *args do_lower_case = False **kwargs )

构建 DPRQuestionEncoder 分词器。

DPRQuestionEncoderTokenizer 与 BertTokenizer 完全相同，并实现了端到端的词法分析：标点符号分割和 wordpiece 分词。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

DPRQuestionEncoderTokenizerFast

class transformers.DPRQuestionEncoderTokenizerFast

< >

( vocab: str | dict[str, int] | None = None do_lower_case: bool = False 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 )

构建一个“快速”的 DPRQuestionEncoder 分词器（基于 HuggingFace 的 tokenizers 库）。

DPRQuestionEncoderTokenizerFast 与 BertTokenizer 完全相同，并实现了端到端的词法分析：标点符号分割和 wordpiece 分词。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

DPRReaderTokenizer

class transformers.DPRReaderTokenizer

< >

( *args do_lower_case = False **kwargs ) → dict[str, list[list[int]]]

参数

  • questions (str 或 list[str]) — 要编码的问题。您可以为多个 passage 指定一个问题。在这种情况下，问题将被复制，如 [questions] * n_passages。否则，您必须指定与 titles 或 texts 一样多的问题。
  • titles (str 或 list[str]) — 要编码的 passage 标题。如果存在多个 passage，则可以是一个字符串或一个字符串列表。
  • texts (str 或 list[str]) — 要编码的 passage 文本。如果存在多个 passage，则可以是一个字符串或一个字符串列表。
  • padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值：

    • True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
    • 'max_length': 填充到参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。
    • False 或 'do_not_pad' (默认): 不填充（即，可以输出不同长度序列的批次）。
  • truncation (bool, str 或 TruncationStrategy, 可选, 默认为 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, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 Numpy np.ndarray 对象。
  • return_attention_mask (bool, 可选) — 是否返回 attention mask。如果未设置，则将根据特定分词器的默认值返回 attention mask，该默认值由 return_outputs 属性定义。

    注意力掩码是什么？

返回

dict[str, list[list[int]]]

包含以下键的字典

  • input_ids: 要馈送到模型的 token ID 列表。
  • attention_mask: 指定模型应关注哪些 token 的索引列表。

构建 DPRReader 分词器。

DPRReaderTokenizer 与 BertTokenizer 几乎相同，并实现了端到端的词法分析：标点符号分割和 wordpiece 分词。区别在于它有三个输入字符串：question、titles 和 texts，它们被组合起来馈送到 DPRReader 模型。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

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

格式如下：

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

DPRReaderTokenizerFast

class transformers.DPRReaderTokenizerFast

< >

( vocab: str | dict[str, int] | None = None do_lower_case: bool = False 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 ) → dict[str, list[list[int]]]

参数

  • questions (str 或 list[str]) — 要编码的问题。您可以为多个 passage 指定一个问题。在这种情况下，问题将被复制，如 [questions] * n_passages。否则，您必须指定与 titles 或 texts 一样多的问题。
  • titles (str 或 list[str]) — 要编码的 passage 标题。如果存在多个 passage，则可以是一个字符串或一个字符串列表。
  • texts (str 或 list[str]) — 要编码的 passage 文本。如果存在多个 passage，则可以是一个字符串或一个字符串列表。
  • padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值：

    • True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
    • 'max_length': 填充到参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。
    • False 或 'do_not_pad' (默认): 不填充（即，可以输出不同长度序列的批次）。
  • truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值：

    • True 或 'longest_first': 截断到参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一个序列批次），则从较长的序列中移除一个 token。
    • 'only_first': 截断到参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一个序列批次），则只截断第一个序列。
    • 'only_second': 截断到参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一个序列批次），则只截断第二个序列。
    • False 或 'do_not_truncate' (默认): 不截断（即，可以输出序列长度大于模型最大允许输入尺寸的批次）。
  • max_length (int, optional) — 控制截断/填充参数使用的最大长度。

    如果未设置或设置为 None，则在截断/填充参数需要最大长度时，将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则截断/填充到最大长度将被禁用。

  • return_tensors (str or TensorType, optional) — 如果设置为，将返回张量而不是 Python 整数列表。可接受的值为：

    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。
  • return_attention_mask (bool, optional) — 是否返回 attention mask。如果未设置，将根据 return_outputs 属性定义的特定分词器的默认值返回 attention mask。

    什么是 attention mask？

返回

dict[str, list[list[int]]]

包含以下键的字典

  • input_ids: 要馈送到模型的 token ID 列表。
  • attention_mask: 指定模型应关注哪些 token 的索引列表。

构造一个“快速”的 DPRReader 分词器（基于 HuggingFace 的tokenizers库）。

DPRReaderTokenizerFast 与 BertTokenizer 几乎相同，并执行端到端分词：标点符号分割和 wordpiece。区别在于它有三个输入字符串：question、titles 和 texts，它们被组合起来输入到 DPRReader 模型。

有关参数的使用示例和文档，请参阅超类 BertTokenizer。

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

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

DPR 特定的输出

class transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput

< >

( pooler_output: FloatTensor hidden_states: tuple[torch.FloatTensor, ...] | None = None attentions: tuple[torch.FloatTensor, ...] | None = None )

参数

  • pooler_output (torch.FloatTensor, shape (batch_size, embeddings_size)) — DPR encoder 输出的 pooler_output，对应于上下文表示。序列第一个 token（分类 token）的最后一层隐藏状态，经过一个线性层进一步处理。此输出用于通过问题 embeddings 来嵌入上下文以进行最近邻查询。
  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出，如果模型有嵌入层，加上每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层的输出处的隐藏状态，加上可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    自注意力头的加权平均计算所用的注意力权重，在注意力 softmax 之后。

DPRQuestionEncoder 输出的类。

class transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput

< >

( pooler_output: FloatTensor hidden_states: tuple[torch.FloatTensor, ...] | None = None attentions: tuple[torch.FloatTensor, ...] | None = None )

参数

  • pooler_output (torch.FloatTensor, shape (batch_size, embeddings_size)) — DPR encoder 输出的 pooler_output，对应于问题表示。序列第一个 token（分类 token）的最后一层隐藏状态，经过一个线性层进一步处理。此输出用于通过上下文 embeddings 来嵌入问题以进行最近邻查询。
  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出，如果模型有嵌入层，加上每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层的输出处的隐藏状态，加上可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    自注意力头的加权平均计算所用的注意力权重，在注意力 softmax 之后。

DPRQuestionEncoder 输出的类。

class transformers.DPRReaderOutput

< >

( start_logits: FloatTensor end_logits: torch.FloatTensor | None = None relevance_logits: torch.FloatTensor | None = None hidden_states: tuple[torch.FloatTensor, ...] | None = None attentions: tuple[torch.FloatTensor, ...] | None = None )

参数

  • start_logits (torch.FloatTensor, shape (n_passages, sequence_length)) — 每个 passage 的 span 起始索引的 Logits。
  • end_logits (torch.FloatTensor, shape (n_passages, sequence_length)) — 每个 passage 的 span 结束索引的 Logits。
  • relevance_logits (torch.FloatTensor, shape (n_passages, )) — DPRReader 的 QA 分类器输出，对应于每个 passage 回答问题的得分，与其他 passage 进行比较。
  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出，如果模型有嵌入层，加上每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层的输出处的隐藏状态，加上可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    自注意力头的加权平均计算所用的注意力权重，在注意力 softmax 之后。

DPRQuestionEncoder 输出的类。

DPRContextEncoder

class transformers.DPRContextEncoder

< >

( config: DPRConfig )

参数

  • config (DPRConfig) — 模型的配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

输出 context 表示的 DPRContextEncoder 的裸 transformer。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。为了匹配预训练，DPR 输入序列应该使用 [CLS] 和 [SEP] token 进行格式化，如下所示：

    (a) 对于序列对（例如，标题+文本对）：

返回

transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），具体取决于配置（DPRConfig）和输入。

  • pooler_output (torch.FloatTensor of shape (batch_size, embeddings_size)) — DPR 编码器输出的 pooler_output，对应于上下文表示。序列的第一个 token（分类 token）的最后一层隐藏状态，经过一个线性层进一步处理。此输出用于通过问题嵌入来嵌入上下文，以进行最近邻查询。

  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出）。

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

DPRContextEncoder 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

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

class transformers.DPRQuestionEncoder

< >

( config: DPRConfig )

参数

  • config (DPRConfig) — 模型的配置类，包含模型的所有参数。使用配置文件初始化不会加载模型权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

输出池化输出作为问题表示的裸 DPRQuestionEncoder transformer。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.models.dpr.DPRQuestionEncoderOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。为了匹配预训练，DPR 输入序列应该使用 [CLS] 和 [SEP] token 进行格式化，如下所示：

    (a) 对于序列对（例如，标题+文本对）：

返回

transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），具体取决于配置（DPRConfig）和输入。

  • pooler_output (torch.FloatTensor of shape (batch_size, embeddings_size)) — DPR 编码器输出的 pooler_output，对应于问题表示。序列的第一个 token（分类 token）的最后一层隐藏状态，经过一个线性层进一步处理。此输出用于通过上下文嵌入来嵌入问题，以进行最近邻查询。

  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出）。

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

DPRQuestionEncoder 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

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

class transformers.DPRReader

< >

( config: DPRConfig )

参数

  • config (DPRConfig) — 模型的配置类，包含模型的所有参数。使用配置文件初始化不会加载模型权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

输出跨度预测的裸 DPRReader transformer。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.models.dpr.DPRReaderOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (tuple[torch.LongTensor] of shapes (n_passages, sequence_length)) — 词汇表中输入序列 token 的索引。它必须是包含 1) 问题，2) 文章标题，和 3) 文章文本的序列三元组。为了匹配预训练，DPR input_ids 序列应该使用 [CLS] 和 [SEP] 进行格式化，格式为：

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

    DPR 是一个具有绝对位置嵌入的模型，因此通常建议右填充输入而不是左填充。

    可以使用 DPRReaderTokenizer 获取索引。有关更多详细信息，请参阅此类的文档。

    什么是 input IDs？

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在 [0, 1] 之间：

    • 1 表示 **未被掩码** 的 token，
    • 0 表示 **被掩码** 的 token。

    什么是 attention masks？

  • inputs_embeds (torch.FloatTensor of shape (n_passages, sequence_length, hidden_size), optional) — 可选地，您可以直接传入嵌入表示，而不是传入 input_ids。如果您想比模型内部的嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联向量，这会很有用。
  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。更多细节请参阅返回的张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。更多细节请参阅返回的张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.dpr.modeling_dpr.DPRReaderOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.dpr.modeling_dpr.DPRReaderOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），具体取决于配置（DPRConfig）和输入。

  • start_logits (torch.FloatTensor of shape (n_passages, sequence_length)) — 每个 passage 的跨度起始索引的 logits。

  • end_logits (torch.FloatTensor of shape (n_passages, sequence_length)) — 每个 passage 的跨度结束索引的 logits。

  • relevance_logits (torch.FloatTensor of shape (n_passages, )) — DPRReader 的 QA 分类器的输出，对应于每个 passage 回答问题的分数，与其他 passage 进行比较。

  • hidden_states (tuple[torch.FloatTensor, ...] | None.hidden_states, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出）。

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple[torch.FloatTensor, ...] | None.attentions, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

DPRReader 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> 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
在 GitHub 上更新

←dots1 ELECTRA→
© . This site is unofficial and not affiliated with Hugging Face, Inc.