Transformers

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

参数

vocab_size (int, 可选, 默认为 30522) — DPR 模型的词汇表大小。定义了可以由传递给 BertModel 的 forward 方法的 inputs_ids 表示的不同标记。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间层”（即前馈层）的维度。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的丢弃率。
max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常，为防止万一，将其设置为一个较大的值（例如 512、1024 或 2048）。
type_vocab_size (int, 可选, 默认为 2) — 传入 BertModel 的 token_type_ids 的词汇表大小。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
pad_token_id (int, 可选, 默认为 0) — 填充标记 ID。
position_embedding_type (str, 可选, 默认为 "absolute") — 位置嵌入的类型。从 "absolute"、"relative_key"、"relative_key_query" 中选择一个。对于位置嵌入，请使用 "absolute"。有关 "relative_key" 的更多信息，请参阅《带相对位置表示的自注意力》（Shaw 等人）。有关 "relative_key_query" 的更多信息，请参阅《用更好的相对位置嵌入改进 Transformer 模型》（Huang 等人）中的 方法 4。
projection_dim (int, 可选, 默认为 0) — 上下文和问题编码器投影的维度。如果设置为零（默认值），则不进行投影。

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

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

构造一个 DPRContextEncoder 分词器。

DPRContextEncoderTokenizer 与 BertTokenizer 相同，并执行端到端的标记化：标点符号分割和词片化。

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

DPRContextEncoderTokenizerFast

class transformers.DPRContextEncoderTokenizerFast

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

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

DPRContextEncoderTokenizerFast 与 BertTokenizerFast 相同，并执行端到端的标记化：标点符号分割和词片化。

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

DPRQuestionEncoderTokenizer

class transformers.DPRQuestionEncoderTokenizer

构造一个 DPRQuestionEncoder 分词器。

DPRQuestionEncoderTokenizer 与 BertTokenizer 相同，并执行端到端的标记化：标点符号分割和词片化。

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

DPRQuestionEncoderTokenizerFast

class transformers.DPRQuestionEncoderTokenizerFast

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

DPRQuestionEncoderTokenizerFast 与 BertTokenizerFast 相同，运行端到端的分词：标点符号分割和 wordpiece。

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

DPRReaderTokenizer

class transformers.DPRReaderTokenizer

参数

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 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将逐个标记进行截断，从最长的序列中移除一个标记。
- 'only_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将只截断第一个序列。
- 'only_second'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将只截断第二个序列。
- False 或 'do_not_truncate' (默认)：不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
max_length (int, 可选) — 控制截断/填充参数使用的最大长度。

如果未设置或设置为 None，并且截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度的功能。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf'：返回 TensorFlow tf.constant 对象。
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 Numpy np.ndarray 对象。
return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果未设置，将根据特定分词器的默认设置返回注意力掩码，该默认设置由 return_outputs 属性定义。

什么是注意力掩码？

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

一个包含以下键的字典：

input_ids：要输入到模型中的词元 ID 列表。
attention_mask：用于指定模型应关注哪些词元的索引列表。

构建一个 DPRReader 分词器。

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

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

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

格式如下：

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

DPRReaderTokenizerFast

class transformers.DPRReaderTokenizerFast

参数

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 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将逐个标记进行截断，从最长的序列中移除一个标记。
- 'only_first'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将只截断第一个序列。
- 'only_second'：截断到由 max_length 参数指定的最大长度，如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列对），这将只截断第二个序列。
- False 或 'do_not_truncate' (默认)：不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
max_length (int, 可选) — 控制截断/填充参数使用的最大长度。

如果未设置或设置为 None，并且截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度的功能。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'tf'：返回 TensorFlow tf.constant 对象。
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 Numpy np.ndarray 对象。
return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果未设置，将根据特定分词器的默认设置返回注意力掩码，该默认设置由 return_outputs 属性定义。

什么是注意力掩码？

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

一个包含以下键的字典：

input_ids：要输入到模型中的词元 ID 列表。
attention_mask：用于指定模型应关注哪些词元的索引列表。

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

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

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

返回一个包含输入字符串词元 ID 以及其他信息以供 .decode_best_spans 使用的字典。它使用分词器和词汇表将问题字符串和不同段落（标题和文本）转换为 ID 序列（整数）。结果 input_ids 是一个大小为 (n_passages, sequence_length) 的矩阵，格式如下：

[CLS] <问题词元 ID> [SEP] <标题 ID> [SEP] <文本 ID>

DPR 特定输出

class transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput

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

参数

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 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每层输出处的隐藏状态以及可选的初始嵌入输出。
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

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

参数

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 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每层输出处的隐藏状态以及可选的初始嵌入输出。
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

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

参数

start_logits (torch.FloatTensor，形状为 (n_passages, sequence_length)) — 每个段落答案范围起始索引的 logits。
end_logits (torch.FloatTensor，形状为 (n_passages, sequence_length)) — 每个段落答案范围结束索引的 logits。
relevance_logits (torch.FloatTensor，形状为 (n_passages, )) — DPRReader 的问答分类器输出，对应于每个段落回答问题的分数，与其他所有段落进行比较。
hidden_states (tuple[torch.FloatTensor, ...], 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

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

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

DPRQuestionEncoder 的输出类。

Pytorch

隐藏 Pytorch 内容

DPRContextEncoder

class transformers.DPRContextEncoder

( config: DPRConfig )

参数

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

裸的 DPRContextEncoder transformer，输出池化输出作为上下文表示。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

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: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput 或 tuple(torch.FloatTensor)

参数

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

(a) 对于序列对（例如，一对 title+text）：

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，对应于上下文表示。序列的第一个词元（分类词元）的最后一层隐藏状态经过线性层进一步处理。此输出用于将上下文嵌入，以便与问题嵌入进行最近邻查询。
hidden_states (tuple[torch.FloatTensor, ...], 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
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__ 特殊方法。

尽管前向传播的流程需要在此函数中定义，但之后应该调用 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 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

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

参数

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 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
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__ 特殊方法。

示例

>>> 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 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

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

参数

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 获得。更多详细信息请参阅此类文档。

什么是 input ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力机制的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
什么是注意力掩码？
inputs_embeds (torch.FloatTensor，形状为 (n_passages, sequence_length, hidden_size)，可选) — 可以选择直接传递嵌入式表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 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)) — 每个段落中答案范围起始索引的 logits。
end_logits (torch.FloatTensor，形状为 (n_passages, sequence_length)) — 每个段落中答案范围结束索引的 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 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
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__ 特殊方法。

示例

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

TensorFlow

隐藏 TensorFlow 内容

TFDPRContextEncoder

class transformers.TFDPRContextEncoder

( config: DPRConfig *args **kwargs )

参数

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

裸的 DPRContextEncoder transformer，输出池化输出作为上下文表示。

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

该模型也是一个 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 函数一样传递输入！

调用

( 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 或 tuple(tf.Tensor)

参数

input_ids (Numpy 数组 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。为了匹配预训练，DPR 输入序列应使用 [CLS] 和 [SEP] 标记格式化，如下所示：

(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 对应于上下文表示。它是序列第一个标记（分类标记）的最后一层隐藏状态，再经过一个线性层处理。此输出用于将上下文嵌入，以便与问题嵌入进行最近邻查询。
hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个是嵌入的输出 + 一个是每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

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

示例

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

TFDPRQuestionEncoder

class transformers.TFDPRQuestionEncoder

( config: DPRConfig *args **kwargs )

参数

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

一个基本的 DPRQuestionEncoder transformer，将池化器输出作为问题表示。

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

该模型也是一个 Tensorflow keras.Model 子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与一般用法和行为相关的事项。

transformers 中的 TensorFlow 模型和层接受两种输入格式

所有输入作为关键字参数（如 PyTorch 模型），或
所有输入作为第一个位置参数中的列表、元组或字典。

只有一个 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 函数一样传递输入！

调用

参数

input_ids (Numpy 数组 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。为了匹配预训练，DPR 输入序列应使用 [CLS] 和 [SEP] 标记格式化，如下所示：

(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 对应于问题表示。它是序列第一个标记（分类标记）的最后一层隐藏状态，再经过一个线性层处理。此输出用于将问题嵌入，以便与上下文嵌入进行最近邻查询。
hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个是嵌入的输出 + 一个是每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

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

示例

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

TFDPRReader

class transformers.TFDPRReader

( config: DPRConfig *args **kwargs )

参数

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

一个基本的 DPRReader transformer，输出跨度预测。

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

该模型也是一个 Tensorflow keras.Model 子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与一般用法和行为相关的事项。

transformers 中的 TensorFlow 模型和层接受两种输入格式

所有输入作为关键字参数（如 PyTorch 模型），或
所有输入作为第一个位置参数中的列表、元组或字典。

只有一个 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 函数一样传递输入！

调用