Transformers 文档
DPR
并获得增强的文档体验
开始使用
DPR
概述
稠密段落检索 (DPR) 是一套用于最先进的开放域问答研究的工具和模型。它在 Dense Passage Retrieval for Open-Domain Question Answering 中被 Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih 提出。
该论文的摘要如下
开放域问答依赖于高效的段落检索来选择候选上下文，而传统的稀疏向量空间模型，如 TF-IDF 或 BM25，是事实上的方法。在这项工作中，我们表明检索实际上可以仅使用稠密表示来实现，其中嵌入是从少量问题和段落中通过简单的双编码器框架学习的。当在各种开放域 QA 数据集上评估时，我们的稠密检索器在 top-20 段落检索准确率方面，大大优于强大的 Lucene-BM25 系统 9%-19% 的绝对值，并帮助我们的端到端 QA 系统在多个开放域 QA 基准测试中建立了新的最先进水平。
使用技巧
DPR 由三个模型组成
- 问题编码器：将问题编码为向量
- 上下文编码器：将上下文编码为向量
- 阅读器：提取检索到的上下文中问题的答案，以及相关性得分（如果推断的跨度实际回答了问题，则得分高）。
DPRConfig
class transformers.DPRConfig
< source >( 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 position_embedding_type = 'absolute' projection_dim: int = 0 **kwargs )
Parameters
- vocab_size (
int, optional, defaults to 30522) — DPR 模型的词汇表大小。定义了可以由传递给 BertModel 的 forward 方法的 inputs_ids 表示的不同 token。 - hidden_size (
int, optional, defaults to 768) — 编码器层和池化层的维度大小。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size (
int, optional, defaults to 3072) — Transformer 编码器中“中间”层（即，前馈层）的维度大小。 - hidden_act (
str或function, optional, defaults to"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - hidden_dropout_prob (
float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 - max_position_embeddings (
int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - type_vocab_size (
int, optional, defaults to 2) — 传递到 BertModel 的 token_type_ids 的词汇表大小。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, optional, defaults to 1e-12) — layer normalization 层使用的 epsilon 值。 - pad_token_id (
int, optional, defaults to 0) — Padding token id，即填充 token 的 id。 - position_embedding_type (
str, optional, defaults to"absolute") — 位置嵌入的类型。从"absolute","relative_key","relative_key_query"中选择一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参阅 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的 *方法 4*。 - projection_dim (
int, optional, defaults to 0) — 上下文编码器和问题编码器的 projection 维度。如果设置为零（默认值），则不进行 projection。
DPRConfig 是用于存储 DPRModel 配置的配置类。
此类是用于存储 DPRContextEncoder, DPRQuestionEncoder, 或 DPRReader 配置的配置类。它用于根据指定的参数实例化 DPR 模型的组件，定义模型组件的架构。使用默认值实例化配置将产生类似于 DPRContextEncoder facebook/dpr-ctx_encoder-single-nq-base 架构的配置。
此类是 BertConfig 的子类。请查看超类文档以获取所有 kwargs 的文档。
Example
>>> 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.configDPRContextEncoderTokenizer
class transformers.DPRContextEncoderTokenizer
< source >( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None clean_up_tokenization_spaces = True **kwargs )
Construct a DPRContextEncoder tokenizer.
DPRContextEncoderTokenizer 与 BertTokenizer 完全相同，并运行端到端的分词：标点符号分割和 wordpiece。
Refer to superclass BertTokenizer for usage examples and documentation concerning parameters.
DPRContextEncoderTokenizerFast
class transformers.DPRContextEncoderTokenizerFast
< source >( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )
Construct a “fast” DPRContextEncoder tokenizer (backed by HuggingFace’s tokenizers library).
DPRContextEncoderTokenizerFast 与 BertTokenizerFast 完全相同，并运行端到端的分词：标点符号分割和 wordpiece。
Refer to superclass BertTokenizerFast for usage examples and documentation concerning parameters.
DPRQuestionEncoderTokenizer
class transformers.DPRQuestionEncoderTokenizer
< source >( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None clean_up_tokenization_spaces = True **kwargs )
构建 DPRQuestionEncoder 分词器。
DPRQuestionEncoderTokenizer 与 BertTokenizer 完全相同，并运行端到端的分词：标点符号分割和 wordpiece。
Refer to superclass BertTokenizer for usage examples and documentation concerning parameters.
DPRQuestionEncoderTokenizerFast
class transformers.DPRQuestionEncoderTokenizerFast
< source >( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )
构建 “快速” DPRQuestionEncoder 分词器（由 HuggingFace 的 tokenizers 库支持）。
DPRQuestionEncoderTokenizerFast 与 BertTokenizerFast 完全相同，并运行端到端的分词：标点符号分割和 wordpiece。
Refer to superclass BertTokenizerFast for usage examples and documentation concerning parameters.
DPRReaderTokenizer
class transformers.DPRReaderTokenizer
< source >( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None clean_up_tokenization_spaces = True **kwargs ) → Dict[str, List[List[int]]]
Parameters
- questions (
str或List[str]) — 要编码的问题。您可以为一个段落指定一个问题。在这种情况下，问题将被复制，如[questions] * n_passages。否则，您必须指定与titles或texts中一样多的问题。 - titles (
str或List[str]) — 要编码的段落标题。如果有多个段落，则可以是字符串或字符串列表。 - texts (
str或List[str]) — 要编码的段落文本。如果有多个段落，则可以是字符串或字符串列表。 - 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, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.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 模型。
Refer to superclass BertTokenizer for usage examples and documentation concerning parameters.
返回一个字典，其中包含输入字符串的 token id 和其他信息，以提供给 .decode_best_spans。它使用分词器和词汇表将问题字符串和不同的段落（标题和文本）转换为 ID（整数）序列。生成的 input_ids 是大小为 (n_passages, sequence_length) 的矩阵
DPRReaderTokenizerFast
class transformers.DPRReaderTokenizerFast
< source >( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs ) → Dict[str, List[List[int]]]
Parameters
- questions (
str或List[str]) — 要编码的问题。您可以为一个段落指定一个问题。在这种情况下，问题将被复制，如[questions] * n_passages。否则，您必须指定与titles或texts中一样多的问题。 - titles (
str或List[str]) — 要编码的段落标题。如果有多个段落，则可以是字符串或字符串列表。 - texts (
str或List[str]) — 要编码的段落文本。如果有多个段落，则可以是字符串或字符串列表。 - 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, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- return_attention_mask (
bool, optional) — 是否返回 attention mask。如果未设置，将根据特定分词器的默认值返回 attention mask，默认值由return_outputs属性定义。
返回值
Dict[str, List[List[int]]]
一个包含以下键的字典
input_ids：要馈送到模型的 token id 列表。attention_mask：指定模型应关注哪些 token 的索引列表。
构建一个 “快速” DPRReader 分词器（由 HuggingFace 的 tokenizers 库支持）。
DPRReaderTokenizerFast 几乎与 BertTokenizerFast 完全相同，并运行端到端的分词：标点符号分割和 wordpiece。不同之处在于它有三个输入字符串：question、titles 和 texts，它们组合在一起被馈送到 DPRReader 模型。
Refer to superclass BertTokenizerFast for usage examples and documentation concerning parameters.
返回一个字典，其中包含输入字符串的 token id 和其他信息，以提供给 .decode_best_spans。它使用分词器和词汇表将问题字符串和不同的段落（标题和文本）转换为 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
< source >( pooler_output: FloatTensor hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
Parameters
- pooler_output (
torch.FloatTensor，形状为(batch_size, embeddings_size)) — DPR 编码器输出与上下文表示相对应的 pooler_output。序列的第一个 token（分类 token）的最后一层隐藏状态，并由线性层进一步处理。此输出用于嵌入上下文，以便使用问题嵌入进行最近邻查询。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（embedding 输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上初始 embedding 输出。
- attentions (
tuple(torch.FloatTensor), 可选, 当传递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
< source >( pooler_output: FloatTensor hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
Parameters
- pooler_output (
torch.FloatTensor，形状为(batch_size, embeddings_size)) — DPR 编码器输出与问题表示相对应的 pooler_output。序列的第一个 token（分类 token）的最后一层隐藏状态，并由线性层进一步处理。此输出用于嵌入问题，以便使用上下文嵌入进行最近邻查询。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（embedding 输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上初始 embedding 输出。
- attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
用于 DPRQuestionEncoder 输出的类。
class transformers.DPRReaderOutput
< source >( start_logits: FloatTensor end_logits: FloatTensor = None relevance_logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
Parameters
- start_logits (
torch.FloatTensor，形状为(n_passages, sequence_length)) — 每个段落的 span 起始索引的 logits。 - end_logits (
torch.FloatTensor，形状为(n_passages, sequence_length)) — 每个段落的 span 结束索引的 logits。 - relevance_logits (
torch.FloatTensor，形状为(n_passages, )) — DPRReader 的 QA 分类器的输出，对应于每个段落回答问题的得分，与其他所有段落相比。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（embedding 输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上初始 embedding 输出。
- attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
用于 DPRQuestionEncoder 输出的类。
DPRContextEncoder
class transformers.DPRContextEncoder
< source >( config: DPRConfig )
Parameters
- config (DPRConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 DPRContextEncoder transformer，输出池化器输出作为上下文表示。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的信息。
forward
< source >( 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: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput or tuple(torch.FloatTensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 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，形状为(batch_size, embeddings_size)) — DPR 编码器输出与上下文表示相对应的 pooler_output。序列的第一个 token（分类 token）的最后一层隐藏状态，并由线性层进一步处理。此输出用于嵌入上下文，以便使用问题嵌入进行最近邻查询。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (每个embedding输出层 + 每个层输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
DPRContextEncoder 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 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_outputDPRQuestionEncoder
class transformers.DPRQuestionEncoder
< source >( config: DPRConfig )
Parameters
- config (DPRConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
输出池化器输出作为问题表示的裸 DPRQuestionEncoder transformer。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的信息。
forward
< source >( 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: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput 或 tuple(torch.FloatTensor)
Parameters
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。为了匹配预训练，DPR 输入序列应使用 [CLS] 和 [SEP] 标记格式化，如下所示：(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，形状为(batch_size, embeddings_size)) — DPR 编码器输出与问题表示相对应的 pooler_output。序列的第一个标记（分类标记）的最后一层隐藏状态，并由线性层进一步处理。此输出用于嵌入问题，以便使用上下文嵌入进行最近邻查询。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (每个embedding输出层 + 每个层输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
DPRQuestionEncoder 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 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_outputDPRReader
class transformers.DPRReader
< source >( config: DPRConfig )
Parameters
- config (DPRConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
输出 span 预测的裸 DPRReader transformer。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取所有与通用用法和行为相关的信息。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.dpr.modeling_dpr.DPRReaderOutput 或 tuple(torch.FloatTensor)
Parameters
- input_ids (
Tuple[torch.LongTensor]，形状为(n_passages, sequence_length)) — 词汇表中输入序列标记的索引。它必须是包含 1) 问题、2) 段落标题和 3) 段落文本的序列三元组。为了匹配预训练，DPRinput_ids序列应使用 [CLS] 和 [SEP] 格式化，格式如下：[CLS] <问题 token ids> [SEP] <标题 ids> [SEP] <文本 ids>DPR 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
索引可以使用 DPRReaderTokenizer 获得。有关更多详细信息，请参阅此类文档。
- attention_mask (
torch.FloatTensor，形状为(n_passages, sequence_length), 可选) — 掩码，以避免在填充 token 索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
- inputs_embeds (
torch.FloatTensor，形状为(n_passages, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 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，形状为(n_passages, sequence_length)) — 每个段落的 span 起始索引的 logits。 -
end_logits (
torch.FloatTensor，形状为(n_passages, sequence_length)) — 每个段落的 span 结束索引的 logits。 -
relevance_logits (
torch.FloatTensor，形状为(n_passages, )) — DPRReader 的 QA 分类器的输出，对应于每个段落回答问题的分数，与其他所有段落相比。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (每个embedding输出层 + 每个层输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
DPRReader 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 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_logitsTFDPRContextEncoder
class transformers.TFDPRContextEncoder
< source >( config: DPRConfig *args **kwargs )
Parameters
- config (DPRConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸 DPRContextEncoder transformer，输出池化器输出作为上下文表示。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝头等）。
此模型也是 Tensorflow keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入都作为关键字参数（如 PyTorch 模型），或
- 所有输入都作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids且不包含其他内容的单个张量：model(input_ids) - 长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → transformers.models.dpr.modeling_tf_dpr.TFDPRContextEncoderOutput or tuple(tf.Tensor)
Parameters
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 为了匹配预训练，DPR 输入序列应使用 [CLS] 和 [SEP] tokens 格式化，如下所示：(a) 对于序列对（例如，标题+文本对）：
返回值
transformers.models.dpr.modeling_tf_dpr.TFDPRContextEncoderOutput 或 tuple(tf.Tensor)
一个 transformers.models.dpr.modeling_tf_dpr.TFDPRContextEncoderOutput 或一个 tf.Tensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (DPRConfig) 和输入。
-
pooler_output (
tf.Tensor，形状为(batch_size, embeddings_size)) — DPR 编码器输出与上下文表示对应的 pooler_output。序列的第一个 token（分类 token）的最后一层隐藏状态，并通过线性层进一步处理。此输出用于嵌入上下文，以便使用问题嵌入进行最近邻查询。 -
hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
TFDPRContextEncoder 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会忽略它们。
示例
>>> from transformers import TFDPRContextEncoder, DPRContextEncoderTokenizer
>>> tokenizer = DPRContextEncoderTokenizer.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> model = TFDPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base", from_pt=True)
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="tf")["input_ids"]
>>> embeddings = model(input_ids).pooler_outputTFDPRQuestionEncoder
class transformers.TFDPRQuestionEncoder
< source >( config: DPRConfig *args **kwargs )
Parameters
- config (DPRConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
输出池化器输出作为问题表示的裸 DPRQuestionEncoder transformer。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝头等）。
此模型也是 Tensorflow keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入都作为关键字参数（如 PyTorch 模型），或
- 所有输入都作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids且不包含其他内容的单个张量：model(input_ids) - 长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → transformers.models.dpr.modeling_tf_dpr.TFDPRQuestionEncoderOutput or tuple(tf.Tensor)
Parameters
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 为了匹配预训练，DPR 输入序列应使用 [CLS] 和 [SEP] tokens 格式化，如下所示：(a) 对于序列对（例如，标题+文本对）：
返回值
transformers.models.dpr.modeling_tf_dpr.TFDPRQuestionEncoderOutput 或 tuple(tf.Tensor)
一个 transformers.models.dpr.modeling_tf_dpr.TFDPRQuestionEncoderOutput 或一个 tf.Tensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (DPRConfig) 和输入。
-
pooler_output (
tf.Tensor，形状为(batch_size, embeddings_size)) — DPR 编码器输出与问题表示对应的 pooler_output。序列的第一个 token（分类 token）的最后一层隐藏状态，并通过线性层进一步处理。此输出用于嵌入问题，以便使用上下文嵌入进行最近邻查询。 -
hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
TFDPRQuestionEncoder 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会忽略它们。
示例
>>> from transformers import TFDPRQuestionEncoder, DPRQuestionEncoderTokenizer
>>> tokenizer = DPRQuestionEncoderTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> model = TFDPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base", from_pt=True)
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="tf")["input_ids"]
>>> embeddings = model(input_ids).pooler_outputTFDPRReader
class transformers.TFDPRReader
< source >( config: DPRConfig *args **kwargs )
Parameters
- config (DPRConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
输出 span 预测的裸 DPRReader transformer。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝头等）。
此模型也是 Tensorflow keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入都作为关键字参数（如 PyTorch 模型），或
- 所有输入都作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 仅包含
input_ids且不包含其他内容的单个张量：model(input_ids) - 长度可变的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → transformers.models.dpr.modeling_tf_dpr.TFDPRReaderOutput or tuple(tf.Tensor)
Parameters
- input_ids (
Numpy array或tf.Tensor，形状为(n_passages, sequence_length)) — 词汇表中输入序列 tokens 的索引。 它必须是包含 1) 问题、2) 文章标题和 3) 文章文本的序列三元组。 为了匹配预训练，DPRinput_ids序列应使用 [CLS] 和 [SEP] 格式化，格式如下：[CLS] <问题 token ids> [SEP] <标题 ids> [SEP] <文本 ids>DPR 是一个具有绝对位置 embeddings 的模型，因此通常建议在右侧而不是左侧填充输入。
索引可以使用 DPRReaderTokenizer 获取。 有关更多详细信息，请参见此类文档。
- attention_mask (
Numpy array或tf.Tensor，形状为(n_passages, sequence_length), 可选) — 掩码，以避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被掩码 的 tokens，
- 0 表示 已被掩码 的 tokens。
- inputs_embeds (
Numpy array或tf.Tensor，形状为(n_passages, sequence_length, hidden_size), 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回的 tensors 下的hidden_states。 此参数只能在即时模式下使用，在图形模式下将使用 config 中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用，在图形模式下，该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为）。
返回值
transformers.models.dpr.modeling_tf_dpr.TFDPRReaderOutput 或 tuple(tf.Tensor)
一个 transformers.models.dpr.modeling_tf_dpr.TFDPRReaderOutput 或一个 tf.Tensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (DPRConfig) 和输入。
-
start_logits (
tf.Tensor，形状为(n_passages, sequence_length)) — 每个文章的 span 的起始索引的 Logits。 -
end_logits (
tf.Tensor，形状为(n_passages, sequence_length)) — 每个文章的 span 的结束索引的 Logits。 -
relevance_logits (
tf.Tensor，形状为(n_passages, )) — DPRReader 的 QA 分类器的输出，对应于每个文章回答问题的分数，与其他所有文章相比。 -
hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始embedding输出的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
TFDPRReader 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的步骤需要在该函数内定义，但应该调用 Module 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会忽略它们。
示例
>>> from transformers import TFDPRReader, DPRReaderTokenizer
>>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> model = TFDPRReader.from_pretrained("facebook/dpr-reader-single-nq-base", from_pt=True)
>>> encoded_inputs = tokenizer(
... questions=["What is love ?"],
... titles=["Haddaway"],
... texts=["'What Is Love' is a song recorded by the artist Haddaway"],
... return_tensors="tf",
... )
>>> outputs = model(encoded_inputs)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> relevance_logits = outputs.relevance_logits