Transformers 文档

RAG

Transformers

加入Hugging Face社区

并获得增强型文档体验的权限

在模型、数据集和Spaces中协作

使用加速推理更快地示例

切换文档主题

开始使用

RAG

概述

检索增强生成（“RAG”）模型结合了预训练密集检索（DPR）和序列到序列模型的力量。RAG模型检索文档，将文档传递给seq2seq模型，然后边缘化生成输出。检索器和seq2seq模块从预训练的模型中初始化，并联合微调，允许检索和生成适配下游任务。

该研究基于论文《针对知识密集型自然语言处理任务的检索增强生成》（Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks），作者为Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, Douwe Kiela。

论文摘要如下

大型预训练语言模型已经被证明在其参数中存储事实知识，并在下游自然语言处理任务上实现了最先进的结果。然而，它们访问和精确操作知识的能力仍然有限，因此在知识密集型任务中，其性能落后于特定任务的架构。此外，为他们决策提供证据和更新其全球知识仍然是开放的研究问题。具有可微分访问明确非参数记忆的预训练模型可以克服这一问题，但迄今为止，这仅在提取下游任务中得到了研究。我们探索了检索增强生成（RAG）通用微调配方——这些模型结合了预训练的自回归和参数记忆模型，用于语言生成。我们引入了RAG模型，其中参数记忆是预训练的seq2seq模型，非参数记忆是维基百科的密集向量索引，使用预训练的神经检索器进行访问。我们比较了两种RAG表达式，一种在整个生成序列中基于相同的检索段落，另一种可以按每个标记使用不同的段落。我们在广泛的专注型自然语言处理任务上微调和评估了我们的模型，并在三个开放领域问答任务上实现了最先进的水平，超越了参数(seq2seq)模型和特定任务检索-提取架构。对于语言生成任务，我们发现RAG模型比最先进的纯参数(seq2seq)基线生成更具体、更多样化和更真实的语言。

此模型由ola13贡献。

使用技巧

检索增强生成（RAG）模型结合了预训练密集检索（DPR）和Seq2Seq模型的力量。RAG模型检索文档，将其传递到seq2seq模型，然后进行边缘化以生成输出。检索器和seq2seq模块从预训练模型初始化，并联合微调，允许检索和生成都适应下游任务。

RagConfig

class transformers.RagConfig

< source >

( vocab_size = None is_encoder_decoder = True prefix = None bos_token_id = None pad_token_id = None eos_token_id = None decoder_start_token_id = None title_sep = ' / ' doc_sep = ' // ' n_docs = 5 max_combined_length = 300 retrieval_vector_size = 768 retrieval_batch_size = 8 dataset = 'wiki_dpr' dataset_split = 'train' index_name = 'compressed' index_path = None passages_path = None use_dummy_dataset = False reduce_loss = False label_smoothing = 0.0 do_deduplication = True exclude_bos_score = False do_marginalize = False output_retrieved = False use_cache = True forced_eos_token_id = None dataset_revision = None **kwargs )

参数

title_sep (str, 可选，默认为 " / ") — 在调用 RagRetriever 时插入到文档标题和文本之间的分隔符。
doc_sep (str, 可选，默认为 " // ") — 在调用 RagRetriever 时插入到文档文本和原始输入之间的分隔符。
n_docs (int, 可选, 默认值为5) — 要检索的文档数量。
max_combined_length (int, 可选, 默认值为300) — 由 __call__() 返回的上下文化输入的最大长度。
retrieval_vector_size (int, 可选, 默认值为768) — 由 RagRetriever 索引的文档嵌入的维度。
retrieval_batch_size (int, 可选，默认值为 8) — 检索批量大小，定义为同时向封装的 faiss 索引发出的查询数量 RagRetriever。
dataset (str, 可选，默认值为 "wiki_dpr") — HuggingFace Datasets 中索引数据集的标识符（使用 datasets.list_datasets() 列出所有可用的数据集和 ID）。
dataset_split (str, 可选，默认值为 "train") — 加载 dataset 的哪个部分。
index_name (str, 可选，默认值为 "compressed") — 与 dataset 关联的索引的索引名称。可以选择 "legacy"、"exact" 和 "compressed"。
index_path (str, 可选) — 磁盘上序列化 faiss 索引的路径。
passages_path (str, 可选) — 与 faiss 索引兼容的文本段落路径。如果使用 LegacyIndex 则是必需的
use_dummy_dataset (bool, 可选, 默认为 False) — 是否加载由 dataset 指定的数据集的“伪造”版本。
label_smoothing (float, 可选, 默认为 0.0) — 只有当 return_loss 设置为 True 时才相关。控制损失计算中标签平滑的 epsilon 参数值。如果设置为 0，则不执行标签平滑。
do_marginalize (bool, 可选，默认值为 False) — 若为 True，将使用 torch.nn.functional.log_softmax 在所有文档上对 logits 进行边际化。
reduce_loss (bool, 可选，默认值为 False) — 是否使用 torch.Tensor.sum 操作来减少 NLL 损失。
do_deduplication (bool, 可选，默认值为 True) — 对于给定的输入，是否要去除来自不同上下文文档的重复生成。在使用分布式后端进行训练时，必须设置为 False。
exclude_bos_score (bool, 可选，默认为 False) — 是否在计算损失时忽略 BOS 标记。
output_retrieved(bool, 可选，默认为 False) — 如果设置为 True，则返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。更多详情请见返回张量。
use_cache (bool, 可选，默认为 True) — 是否让模型返回最后一个 key/values 关注（不是所有模型都使用）。
forced_eos_token_id (int, 可选) — 当 max_length 达到时，强制用作最后一个生成标记的标记的 id。通常设置为 eos_token_id。

RagConfig 存储了一个 RagModel 的配置。配置对象继承自 PretrainedConfig，并且可用作控制模型输出。更多详情请阅读 PretrainedConfig 的文档。

from_question_encoder_generator_configs

< 源代码 >

( question_encoder_config: PretrainedConfig generator_config: PretrainedConfig **kwargs ) → EncoderDecoderConfig

返回值

EncoderDecoderConfig

配置对象的一个实例

从预训练的编码器模型配置和解码器模型配置中实例化一个 EncoderDecoderConfig（或其子类）。

RagTokenizer

类 transformers.RagTokenizer

< 源代码 >

（ question_encoder generator ）

特定于Rag的输出

类 transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput

< 源代码 >

( loss: 可选 = Nonelogits: FloatTensor = Nonedoc_scores: FloatTensor = Nonepast_key_values: 可选 = Noneretrieved_doc_embeds: 可选 = Noneretrieved_doc_ids: 可选 = Nonecontext_input_ids: 可选 = Nonecontext_attention_mask: 可选 = Nonequestion_encoder_last_hidden_state: 可选 = Nonequestion_enc_hidden_states: 可选 = Nonequestion_enc_attentions: 可选 = Nonegenerator_enc_last_hidden_state: 可选 = Nonegenerator_enc_hidden_states: 可选 = Nonegenerator_enc_attentions: 可选 = Nonegenerator_dec_hidden_states: 可选 = Nonegenerator_dec_attentions: 可选 = Nonegenerator_cross_attentions: 可选 = None )

参数

loss (torch.FloatTensor 形状 (1,), 可选，当提供 labels 时返回) —— 语言模型损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测得分。该得分可能是对每个词汇标注对所有文档的边际化。
doc_scores (torch.FloatTensor of shape (batch_size, config.n_docs)) — 每个检索到的文档嵌入（见retrieved_doc_embeds）和question_encoder_last_hidden_state之间的得分。
past_key_values (List[torch.FloatTensor], 可选，当use_cache=True传入或者当config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含解码器预计算的隐藏状态（注意块中的键和值），可用于快速序列解码（见past_key_values输入）。
retrieved_doc_embeds（torch.FloatTensor 格式，形状为 (batch_size, config.n_docs, hidden_size)，可选，当 output_retrieved=True 时返回） — 由检索器检索到的文档嵌入。与 question_encoder_last_hidden_state 一起使用以计算 doc_scores。
retrieved_doc_ids（torch.LongTensor 格式，形状为 (batch_size, config.n_docs)，可选，当 output_retrieved=True 时返回） — 由检索器检索到的嵌入文档的索引。
context_input_ids（torch.LongTensor 格式，形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回） — 由检索器从检索到的文档和问题编码器输入_ids 后处理后的输入 ids。
context_attention_mask (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) —— 由检索器从检索到的文档和问题编码器的 input_ids 后处理得到的注意力掩码。
question_encoder_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选) —— 模型问题编码器最后一层输出池化后的序列隐藏状态。
question_enc_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) —— 一个 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每层输出）的形状为 (batch_size, sequence_length, hidden_size)。
每层输出以及初始嵌入输出的问题编码器隐藏状态。
question_enc_attentions （tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 每一层的 torch.FloatTensor 的元组（形状为 (batch_size, num_heads, sequence_length, sequence_length)）。
generator_enc_last_hidden_state （形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选） — 模型生成器编码器最后一层的隐藏状态序列。
generator_enc_hidden_states （tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。
generator_enc_attentions (一个torch.FloatTensor的tuple，可选，当通过output_attentions=True传递或当config.output_attentions=True时返回) —— 包含每个层的torch.FloatTensor（一层的注意力权重）的tuple，形状为(batch_size, num_heads, sequence_length, sequence_length)。
generator_dec_hidden_states (一个torch.FloatTensor的tuple，可选，当通过output_hidden_states=True传递或当config.output_hidden_states=True时返回) —— 包含嵌入输出和每个层输出的torch.FloatTensor的tuple，形状为(batch_size, sequence_length, hidden_size)。

generator_dec_attentions (一个torch.FloatTensor的tuple，可选，当通过output_attentions=True传递或当config.output_attentions=True时返回) —— 包含每个层的torch.FloatTensor（一层的注意力权重）的tuple，形状为(batch_size, num_heads, sequence_length, sequence_length)。

generator_cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 每个层对应一个维度为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor的元组。

检索增强边缘模型输出的基本类。

class transformers.models.rag.modeling_rag.RetrievAugLMOutput

< source >

( logits: FloatTensor = None doc_scores: FloatTensor = None past_key_values: Optional = None retrieved_doc_embeds: Optional = None retrieved_doc_ids: Optional = None context_input_ids: Optional = None context_attention_mask: Optional = None question_encoder_last_hidden_state: Optional = None question_enc_hidden_states: Optional = None question_enc_attentions: Optional = None generator_enc_last_hidden_state: Optional = None generator_enc_hidden_states: Optional = None generator_enc_attentions: Optional = None generator_dec_hidden_states: Optional = None generator_dec_attentions: Optional = None generator_cross_attentions: Optional = None )

参数

logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数。分数可能是对每个词汇标记的所有文档边缘化的。
doc_scores (torch.FloatTensor 形状 (batch_size, config.n_docs)) — 每个检索到的文档嵌入（retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的分数。
past_key_values (List[torch.FloatTensor]，可选，在通过 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 torch.FloatTensor 列表，每个张量形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。
其中包含用于（past_key_values 输入）加速序列解码的解码器中预先计算的隐藏状态（注意块中的键和值）。
retrieved_doc_embeds (torch.FloatTensor 形状 (batch_size, config.n_docs, hidden_size)，可选，当 output_retrieved=True 时返回) — 检索器检索的嵌入文档。与 question_encoder_last_hidden_state 一起使用来计算 doc_scores。
retrieved_doc_ids (torch.LongTensor，形状为(batch_size, config.n_docs)，可选，当output_retrieved=True时返回) — 由检索器检索到的嵌入文档的索引。
context_input_ids (torch.LongTensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 检索器由检索到的文档和问题编码器的input_ids输入后处理的输入id。
context_attention_mask (torch.LongTensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 检索器由检索到的文档和问题编码器的input_ids输入后处理的注意力掩码。
question_encoder_last_hidden_state (torch.FloatTensor 的 shape 为 (batch_size, sequence_length, hidden_size)，可选) — 模型问题编码器输出池化后的最后一层的隐藏状态序列。
question_enc_hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 包含 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出），其 shape 为 (batch_size, sequence_length, hidden_size)。
每一层问题编码器的隐藏状态以及初始嵌入输出。
question_enc_attentions (tuple(torch.FloatTensor)，可选，在传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 由 torch.FloatTensor 组成的元组（每个层一个），其 shape 为 (batch_size, num_heads, sequence_length, sequence_length)。
问题编码器在每个层的注意权重，用于计算自我注意力头中的加权平均。
generator_enc_last_hidden_state (torch.FloatTensor 形状 (batch_size, sequence_length, hidden_size)，可选) — 模型生成器编码器最后一层的输出隐藏状态序列。
generator_enc_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或配置 config.output_hidden_states=True 时返回) — 一个由 torch.FloatTensor 组成的元组（一个用于嵌入输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

生成器编码器每个层输出的隐藏状态以及初始嵌入输出。
generator_enc_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或配置 config.output_attentions=True 时返回) — 由 torch.FloatTensor 组成的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

生成器编码器在注意力softmax后的注意力权重，用于在自注意力头中计算加权平均。
generator_dec_hidden_states （tuple(torch.FloatTensor)，可选，当传入 output_hidden_states=True 或配置文件中的 config.output_hidden_states=True 时返回）—— 包含torch.FloatTensor的元组（一个用于嵌入输出，一个用于每层输出），形状为(batch_size, sequence_length, hidden_size)。
生成器解码器每层的隐藏状态输出以及初始嵌入输出。
generator_dec_attentions （tuple(torch.FloatTensor)，可选，当传入 output_attentions=True 或配置文件中的 config.output_attentions=True 时返回）—— 包含torch.FloatTensor的元组（针对每个层），形状为(batch_size, num_heads, sequence_length, sequence_length)。
生成器解码器经过注意力softmax后的注意力权重，用于计算自注意力头中的加权平均值。
generator_cross_attentions （tuple(torch.FloatTensor)，可选，当传入 output_attentions=True 或配置文件中的 config.output_attentions=True 时返回）—— 包含torch.FloatTensor的元组（针对每个层），形状为(batch_size, num_heads, sequence_length, sequence_length)。
生成器解码器交叉注意力权重，在注意力softmax后使用，用于计算交叉注意力头中的加权平均值。

RagRetriever

类 transformers.RagRetriever

< source >

( config question_encoder_tokenizer generator_tokenizer index = None init_retrieval = True )

参数

config (RagConfig) — 该检索器使用的 RAG 模型的配置。包含指示要构建哪个 Index 的参数。您可以使用 config.index_name="custom" 加载自己的自定义数据集，或使用来自数据集库的规范数据集（默认）例如，使用 config.index_name="wiki_dpr"。
question_encoder_tokenizer (预训练标记器) — 用于标记问题的标记器。它用于解码问题并随后使用generator_tokenizer。
generator_tokenizer (预训练标记器) — 用于RagModel的生成部分的标记器。
index (索引, 可选，默认为配置中定义的一个) — 如果指定，则使用此索引代替由配置构建的一个

用于从向量查询中获取文档的检索器。它检索文档的嵌入以及文档内容，并将它们格式化为与RagModel一起使用。

示例

>>> # To load the default "wiki_dpr" dataset with 21M passages from wikipedia (index name is 'compressed' or 'exact')
>>> from transformers import RagRetriever

>>> retriever = RagRetriever.from_pretrained(
...     "facebook/dpr-ctx_encoder-single-nq-base", dataset="wiki_dpr", index_name="compressed"
... )

>>> # To load your own indexed dataset built with the datasets library. More info on how to build the indexed dataset in examples/rag/use_own_knowledge_dataset.py
>>> from transformers import RagRetriever

>>> dataset = (
...     ...
... )  # dataset must be a datasets.Datasets object with columns "title", "text" and "embeddings", and it must have a faiss index
>>> retriever = RagRetriever.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base", indexed_dataset=dataset)

>>> # To load your own indexed dataset built with the datasets library that was saved on disk. More info in examples/rag/use_own_knowledge_dataset.py
>>> from transformers import RagRetriever

>>> dataset_path = "path/to/my/dataset"  # dataset saved via *dataset.save_to_disk(...)*
>>> index_path = "path/to/my/index.faiss"  # faiss index saved via *dataset.get_index("embeddings").save(...)*
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/dpr-ctx_encoder-single-nq-base",
...     index_name="custom",
...     passages_path=dataset_path,
...     index_path=index_path,
... )

>>> # To load the legacy index built originally for Rag's paper
>>> from transformers import RagRetriever

>>> retriever = RagRetriever.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base", index_name="legacy")

init_retrieval

< source >

( )

Retriever 初始化函数。它将索引加载到内存中。

postprocess_docs

< source >

( docs input_strings prefix n_docs return_tensors = None ) → tuple(tensors)

参数

docs (dict) — 检索到的文档。
input_strings (str) — 由 preprocess_query 解码的输入字符串。
prefix (str) — 在每个输入前添加的词缀，通常与基于T5的模型一起使用。

返回值

utuple张量

一个由两个元素组成的元组：上下文化的 input_ids 和相应的 attention_mask。

后处理检索到的 docs 并与 input_strings 结合。

检索

< 源代码 >

( question_hidden_states: 数组 n_docs: 整数 ) → 数组的数组，数组的数组，字典型列表

参数

question_hidden_states (np.ndarray of shape (batch_size, vector_size)) — 要检索的查询向量的批量。
n_docs (int) — 每个查询检索的文档数量。

返回值

Tuple[np.ndarray, np.ndarray, List[dict]]

包含以下对象的元组

retrieved_doc_embeds (np.ndarray of shape (batch_size, n_docs, dim)) — 每个查询的检索文档嵌入。
doc_ids (np.ndarray of shape (batch_size, n_docs)) — 索引中文档的id
doc_dicts (List[dict]): 每个retrieved_doc_embeds示例。

检索指定question_hidden_states的文档。

Pytorch

隐藏Pytorch内容

RagModel

class transformers.RagModel

< 源代码 >

( config: 可选 = None question_encoder: 可选 = None generator: 可选 = None retriever: 可选 = None **其他参数 )

参数

config (RagConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化时，不会加载模型相关的权重，只会加载配置。请参考from_pretrained()方法来加载模型权重。
question_encoder (PreTrainedModel) — 一个与retriever封装的faiss索引兼容的编码器模型。
generator (PreTrainedModel) — 在 RAG 架构中用作生成器的序列到序列模型。
retriever (RagRetriever) — 封装用于查询当前输入上下文文档的 faiss 索引的检索器类。

RagModel 的 forward 方法重写了特殊方法 __call__。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

RAG 是一个封装了两个核心组件的序列到序列模型：问题编码器和生成器。在向前传递过程中，我们将输入通过问题编码器进行编码，并通过检索器提取相关上下文文档。然后，文档将添加到输入之前。将这种上下文化的输入传递到生成器。

问题编码器可以是任何 autoencoding 模型，最好选择 DPRQuestionEncoder，而生成器可以是任何 seq2seq 模型，最好选择 BartForConditionalGeneration。

模型可以使用 RagRetriever 对端到端生成进行初始化，或将其与检索器输出的多个步骤结合使用—更多详细信息请参阅示例。该模型与任何 autoencoding 模型兼容，作为 question_encoder，与任何具有语言模型头的 seq2seq 模型兼容，作为 generator。它已与 DPRQuestionEncoder 作为 question_encoder，与 BartForConditionalGeneration 或 T5ForConditionalGeneration 作为 generator 进行测试。

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

此模型同时也是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与通用用法和行为相关的主题。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None encoder_outputs: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None past_key_values: Optional = None doc_scores: Optional = None context_input_ids: Optional = None context_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_retrieved: Optional = None n_docs: Optional = None ) → transformers.models.rag.modeling_rag.RetrievAugLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列单词在词汇表中的索引。RagConfig，用于初始化模型，指定使用哪个生成器，还指定了一个兼容的生成器标记器。使用该标记器类来获取索引。

什么是指令 ID？
attention_mask (torch.Tensor of shape (batch_size, sequence_length), 可选) — 避免对填充字典索引执行注意力的掩码。所选掩码值在 [0, 1] 之间：
- 1 表示 未掩码 的单词，
- 0 表示掩码的单词。
什么是注意力掩码？
encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 组成元组（generator_enc_last_hidden_state，可选：generator_enc_hidden_states，可选：generator_enc_attentions）。generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size)，是生成器编码器最后层的隐藏状态序列。

在 decoding 期间由 RagModel 模型使用。
decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), 可选) — 为生成任务提供。默认为None，根据您使用的RAG实例的生成器模型说明进行构建。
decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), 可选) — 默认行为：生成一个 Tensor，忽略decoder_input_ids中的 pad tokens。默认使用因果掩码。
past_key_values (tuple(tuple(torch.FloatTensor))) — Tuple 包含两个元素：RAG 模型的 encoder_outputs（见encoder_outputs）以及底层生成器的past_key_values。可用于加速解码。在解码时使用 (RagTokenForGeneration) 模型。
doc_scores (torch.FloatTensor of shape (batch_size, config.n_docs)) — 每个检索到的文档嵌入（见retrieved_doc_embeds）与question_encoder_last_hidden_state之间的得分。如果模型没有初始化retriever，则必须在向前传递中提供doc_scores。可以通过question_encoder_last_hidden_state和retrieved_doc_embeds来计算doc_scores，有关更多信息请参阅示例。
context_input_ids （形状为torch.LongTensor (batch_size * config.n_docs, config.max_combined_length)，可选，在output_retrieved=True时返回） — 经过检索到的文档和问题编码器输入input_ids后的检索器后处理的输入ID。如果模型没有初始化retriever，则必须在向前传递中提供context_input_ids。由__call__()返回context_input_ids。
context_attention_mask （形状为torch.LongTensor (batch_size * config.n_docs, config.max_combined_length)，可选，在output_retrieved=True时返回） — 经过检索到的文档和问题编码器输入input_ids后的检索器后处理的注意掩码。如果模型没有初始化retriever，则必须在向前传递中提供context_attention_mask。由__call__()返回context_attention_mask。
use_cache (bool, 可选，默认为 True) — 如果设置为 True，将返回 past_key_values 的键值状态，可以用来自动加速解码（见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。见返回张量下的 attentions 了解更多详情。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。见返回张量下的 hidden_states 了解更多详情。
output_retrieved(bool, `可选`) — 是否返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。有关更多详细信息，请参阅返回的张量。
n_docs (`int，`可选，默认为 `config.n_docs“`) — 要检索和/或为回答生成答案的文档数量。

返回值

transformers.models.rag.modeling_rag.RetrievAugLMOutput 或 `tuple(torch.FloatTensor)`

它是一个 `transformers.models.rag.modeling_rag.RetrievAugLMOutput` 或一个由 torch.FloatTensor 组成的元组（如果传递了 `return_dict=False` 或当 `config.return_dict=False`），根据配置（`RagConfig》）和输入而包含不同的元素。

logits (`torch.FloatTensor，形状为 `(batch_size, sequence_length, config.vocab_size)`） — 语言模型头的预测分数。该分数可能在所有文档上对所有词汇表标记进行边缘化。
doc_scores (`torch.FloatTensor，形状为 `(batch_size, config.n_docs)`） — 每个检索到的文档嵌入（参见`retrieved_doc_embeds`) 与 `question_encoder_last_hidden_state`之间的得分。
past_key_values (`List[torch.FloatTensor]，`可选`，仅在传递 `use_cache=True` 或当 `config.use_cache=True` 时返回) — 长度为 `config.n_layers` 的 `torch.FloatTensor` 列表，其中每个张量的形状为 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
retrieved_doc_embeds (`torch.FloatTensor，形状为 `(batch_size, config.n_docs, hidden_size)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档。与 `question_encoder_last_hidden_state` 一起使用来计算 `doc_scores`。
retrieved_doc_ids (`torch.LongTensor，形状为 `(batch_size, config.n_docs)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档的索引。
context_input_ids (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的输入 input_ids。
context_attention_mask (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的 input_ids 的注意掩码。
question_encoder_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 问题编码器模型的池化输出的最后层输出的隐藏状态序列。
question_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

在每个层输出加上初始嵌入输出的问题编码器的隐藏状态。
question_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型生成器编码器的最后层输出的隐藏状态序列。
generator_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（一个用于每个层）。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_cross_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

交叉注意力权重，在注意软最大值之后，用于计算交叉注意头中的加权平均。

RagModel 的 forward 方法重写了特殊方法 __call__。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> from transformers import AutoTokenizer, RagRetriever, RagModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-base")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-base", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagModel.from_pretrained("facebook/rag-token-base", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> outputs = model(input_ids=inputs["input_ids"])

RagSequenceForGeneration

类 transformers.RagSequenceForGeneration

< source >

( config: 可选 = None question_encoder: 可选 = None generator: 可选 = None retriever: 可选 = None **其他参数 )

参数

config (RagConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看from_pretrained()方法来加载模型权重。
question_encoder （PreTrainedModel）—— 一个与 retriever 封装的 faiss 指数兼容的编码模型。
generator （PreTrainedModel）—— 在 RAG 架构中用作生成器的 seq2seq 模型。
retriever （RagRetriever）—— 一个封装 faiss 指数的检索类，用于查询以获取当前输入的上下文文档。

RagSequenceForGeneration 的前向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

一个 RAG-序列模型实现。它在前向传递中执行 RAG-序列的特定边缘归一化。

问题编码器可以是任何 autoencoding 模型，最好选择 DPRQuestionEncoder，而生成器可以是任何 seq2seq 模型，最好选择 BartForConditionalGeneration。

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

此模型同时也是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与通用用法和行为相关的主题。

forward

< 来源 >

( input_ids: 可选 = None attention_mask: 可选 = None encoder_outputs: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None past_key_values: 可选 = None context_input_ids: 可选 = None context_attention_mask: 可选 = None doc_scores: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None output_retrieved: 可选 = None exclude_bos_score: 可选 = None reduce_loss: 可选 = None labels: 可选 = None n_docs: 可选 = None **kwargs ) → transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状是 (batch_size, sequence_length)) — 词汇表中的输入序列标记的索引。用于初始化模型的 RagConfig 指定了要使用的生成器，它还指定了一个兼容的生成器标记器。使用该标记器类来获取索引。

什么是输入ID？
attention_mask (torch.Tensor 形状是 (batch_size, sequence_length)，可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]：
- 1 对于 未掩码 的标记，
- 0 对于掩码的标记。
什么是注意力掩码？
encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 包含（generator_enc_last_hidden_state，可选：generator_enc_hidden_states，可选：generator_enc_attentions）。generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size)，是生成器编码器最后层的隐藏状态序列。

在解码过程中，由 (RagModel) 模型使用。
decoder_input_ids （形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选） — 为生成任务提供。默认值为 None，根据您使用的 RAG 实例中生成模型的说明进行构建。
decoder_attention_mask （形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor，可选） — 默认行为：在 decoder_input_ids 中忽略填充标记。默认也将使用因果掩码。
past_key_values （tuple(tuple(torch.FloatTensor))） — 包含两个元素的元组：RAG 模型的 encoder_outputs （见 encoder_outputs）和底层数据生成器的 past_key_values。可用于加速解码。past_key_values 在解码时的 (RagTokenForGeneration) 模型中使用。
doc_scores (torch.FloatTensor 形状为 (batch_size, config.n_docs)) — 每个检索到的文档嵌入（见 retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的分数。如果模型未被初始化为带有 retriever，则在正向传递中必须提供 doc_scores。可以通过 question_encoder_last_hidden_state 和 retrieved_doc_embeds 计算得分，更多详细信息请参见示例。
context_input_ids (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) — 由检索器处理检索到的文档和问题编码器 input_ids 后的输入 ID。如果模型在初始化时未带 retriever，则正向传递中必须提供 context_input_ids。context_input_ids 由 __call__() 返回。
context_attention_mask (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) — 由检索器处理检索到的文档和问题编码器 input_ids 后的注意力掩码。如果模型在初始化时未带 retriever，则正向传递中必须提供 context_attention_mask。context_attention_mask 由 __call__() 返回。
use_cache (bool, 可选, 默认为 True) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
output_retrieved(bool, 可选) — 是否返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。详见返回的张量以获取更多详细信息。
n_docs (int, 可选, 默认为 `config.n_docs`) — 要检索的文档数量以及为生成答案的文档数量。
exclude_bos_score (bool, 可选) — 只有在传递 labels 时才相关。如果设置为 True，在计算损失时将忽略 BOS 标记的得分。
reduce_loss (bool, 可选) — 如果传递了 labels，则相关。如果为 True，则使用 torch.Tensor.sum 操作来减少 NLL 损失。
kwargs (Dict[str, any], 可选, 默认为 {}) — 过时的字典，用于使模型可以使用 generate() 函数。

返回值

transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或一个包含多个元素的 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False），这些元素取决于配置（RagConfig）和输入。

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言模型损失。
logits (`torch.FloatTensor，形状为 `(batch_size, sequence_length, config.vocab_size)`） — 语言模型头的预测分数。该分数可能在所有文档上对所有词汇表标记进行边缘化。
doc_scores (`torch.FloatTensor，形状为 `(batch_size, config.n_docs)`） — 每个检索到的文档嵌入（参见`retrieved_doc_embeds`) 与 `question_encoder_last_hidden_state`之间的得分。
past_key_values (`List[torch.FloatTensor]，`可选`，仅在传递 `use_cache=True` 或当 `config.use_cache=True` 时返回) — 长度为 `config.n_layers` 的 `torch.FloatTensor` 列表，其中每个张量的形状为 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
retrieved_doc_embeds (`torch.FloatTensor，形状为 `(batch_size, config.n_docs, hidden_size)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档。与 `question_encoder_last_hidden_state` 一起使用来计算 `doc_scores`。
retrieved_doc_ids (`torch.LongTensor，形状为 `(batch_size, config.n_docs)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档的索引。
context_input_ids (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的输入 input_ids。
context_attention_mask (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的 input_ids 的注意掩码。
question_encoder_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 问题编码器模型的池化输出的最后层输出的隐藏状态序列。
question_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

在每个层输出加上初始嵌入输出的问题编码器的隐藏状态。
question_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型生成器编码器的最后层输出的隐藏状态序列。
generator_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（一个用于每个层）。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_cross_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

交叉注意力权重，在注意软最大值之后，用于计算交叉注意头中的加权平均。

RagSequenceForGeneration 的前向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> from transformers import AutoTokenizer, RagRetriever, RagSequenceForGeneration
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-sequence-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-sequence-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagSequenceForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> targets = tokenizer(text_target="In Paris, there are 10 million people.", return_tensors="pt")
>>> input_ids = inputs["input_ids"]
>>> labels = targets["input_ids"]
>>> outputs = model(input_ids=input_ids, labels=labels)

>>> # or use retriever separately
>>> model = RagSequenceForGeneration.from_pretrained("facebook/rag-sequence-nq", use_dummy_dataset=True)
>>> # 1. Encode
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.detach().numpy(), return_tensors="pt")
>>> doc_scores = torch.bmm(
...     question_hidden_states.unsqueeze(1), docs_dict["retrieved_doc_embeds"].float().transpose(1, 2)
... ).squeeze(1)
>>> # 3. Forward to generator
>>> outputs = model(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=labels,
... )

generate

< source >

( input_ids: 可选 = None attention_mask: 可选 = None context_input_ids: 可选 = None context_attention_mask: 可选 = None doc_scores: 可选 = None do_deduplication: 可选 = None num_return_sequences: 可选 = None num_beams: 可选 = None n_docs: 可选 = None *model_kwargs ) → torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 作为生成提示的序列。如果未提供 input_ids，则必须提供 context_input_ids。
attention_mask (torch.Tensor 的形状为 (batch_size, sequence_length)，可选) — 用于避免在填充token索引上执行注意力的掩码。选中的掩码值在 [0, 1] 之间：
- 1 表示不是被 掩码的 token,
- 0 表示被 掩码的 token。
什么是注意力掩码？
context_input_ids (torch.LongTensor 的形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) — 从检索到的文档和问题编码器的输入 IDs 中经过后处理的输入 IDs。
context_attention_mask (torch.LongTensor 的形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) — 从检索到的文档和问题编码器的输入ids中经过后处理的注意力掩码。
如果模型没有初始化retriever 或没有提供 input_ids，必须在正向传递中提供 context_input_ids 和 context_attention_mask。它们由 __call__() 返回。
doc_scores (torch.FloatTensor 形状 (batch_size, config.n_docs)) — 每个检索到的文档嵌入（见 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之间的分数。

如果在没有初始化 retriever 或者没有提供 input_ids 的情况下，doc_scores 必须在正向传递中提供。doc_scores 由 __call__() 返回。
do_deduplication (bool, 可选) — 是否为给定输入的来自不同上下文文档的生成内容进行去重。在联合后端训练时必须设置为 False。
num_return_sequences(int, 可选，默认为 1) — 每个批处理元素返回的独立计算序列的数量。请注意，这并不是我们传递给 generator 的 [generate()](/docs/transformers/v4.44.0/en/main_classes/text_generation#transformers.GenerationMixin.generate) 函数的值，在那里我们将 num_return_sequences 设置为 num_beams。
num_beams (int, 可选, 默认为 1) — Beam 搜索的 beam 数量。1 表示没有 beam 搜索。
n_docs (int, 可选, 默认为 config.n_docs) — 要检索的文档数或要生成答案的文档数。
kwargs (Dict[str, Any], 可选) — 将传递到generate()的额外 kwargs。

返回值

torch.LongTensor，形状为 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二个维度（序列长度）可能等于 max_length 或更短，如果所有批次因 eos_token_id 而提前完成。

实现了 RAG 序列“彻底”解码。有关如何设置其他生成输入参数的更多信息，请参阅generate() 文档。

RagTokenForGeneration

类 transformers.RagTokenForGeneration

源码

( config: 可选 = None question_encoder: 可选 = None generator: 可选 = None retriever: 可选 = None **其他参数 )

参数

config (RagConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看from_pretrained() 方法来加载模型权重。
question_encoder (PreTrainedModel) — 与 retriever 封装 faiss 指数兼容的编码器模型。
generator (预训练模型) — 在RAG架构中用作生成器的seq2seq模型。
retriever (RagRetriever) — 封装faiss索引的检索类，用于检索当前输入的上下文文档。

RagTokenForGeneration 前向方法，重写了__call__特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

RAG-token模型实现。它在前向传递中执行RAG-token特定的边际化。

问题编码器可以是任何 autoencoding 模型，最好选择 DPRQuestionEncoder，而生成器可以是任何 seq2seq 模型，最好选择 BartForConditionalGeneration。

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

此模型同时也是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与通用用法和行为相关的主题。

forward

< 来源 >

（ input_ids: 可选 = None attention_mask: 可选 = None encoder_outputs: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None past_key_values: 可选 = None context_input_ids: 可选 = None context_attention_mask: 可选 = None doc_scores: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None output_retrieved: 可选 = None do_marginalize: 可选 = None reduce_loss: 可选 = None labels: 可选 = None n_docs: 可选 = None **kwargs ） → transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或 tuple(torch.FloatTensor)

参数

input_ids （形状为 (batch_size, sequence_length) 的 torch.LongTensor）——词汇表中的输入序列标记的索引。《RagConfig》，用于初始化模型，指定使用哪个生成器，它还指定了一个兼容的生成器分词器。使用该分词器类来获取索引。

输入 ID 是什么？
attention_mask （形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）——避免对填充标记索引执行注意力的掩码。掩码值选在 [0, 1]：
- 1 表示 未掩码 的标记，
- 0 表示掩码的标记。
注意掩码是什么？
encoder_outputs （tuple(tuple(torch.FloatTensor)，可选）——由 generator_enc_last_hidden_state，可选：generator_enc_hidden_states，可选：generator_enc_attentions 组成。 generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size) 是生成器编码器最后层的隐藏状态序列。

在解码过程中由 RagModel 模型使用。
decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), 可选) — 为生成任务提供。默认为None，根据您与RAG实例一起使用的生成器模型的说明进行构造。
decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略decoder_input_ids中的填充标记的张量。默认也将使用因果掩码。
past_key_values (tuple(tuple(torch.FloatTensor))) — 元组包含两个元素：RAG模型的encoder_outputs（参见encoder_outputs）和底层生成器的past_key_values。可用于加速解码。past_key_values用于解码过程中的（《RagTokenForGeneration》）模型。
doc_scores (torch.FloatTensor of shape (batch_size, config.n_docs)) — 每个检索到的文档嵌入（参见 retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的分数。如果模型没有使用 retriever 初始化，则必须在正向传递中提供 doc_scores。可以通过 question_encoder_last_hidden_state 和 retrieved_doc_embeds 计算得分，更多信息请参阅示例。
context_input_ids (torch.LongTensor of shape (batch_size * config.n_docs, config.max_combined_length), optional, returned when output_retrieved=True) — 来自检索到的文档和问题编码器 input_ids 的处理后的输入 IDs，由检索器返回。如果没有使用 retriever 初始化模型，则必须在正向传递中提供 `context_input_ids。
context_attention_mask (torch.LongTensor of shape (batch_size * config.n_docs, config.max_combined_length),optional, returned when output_retrieved=True) — 来自检索到的文档和问题编码器 input_ids 的处理后的注意力掩码，由检索器返回。如果没有使用 retriever 初始化模型，则必须在正向传递中提供 context_attention_mask。
use_cache（《布尔值》，可选，默认为True）— 若设置为True，将返回past_key_values键值状态，并可用来加速解码（见past_key_values）。
output_attentions（《布尔值》，可选）— 是否返回所有注意力层的注意力张量。更多详情见返回张量下的attentions。
output_hidden_states（《布尔值》，可选）— 是否返回所有层的隐藏状态。更多详情见返回张量下的hidden_states。
output_retrieved(bool, 可选) — 是否返回retrieved_doc_embeds、retrieved_doc_ids、context_input_ids和context_attention_mask。关于更详细的信息，请参见返回的张量。
n_docs (int, 可选, 默认为 `config.n_docs`) — 要检索的文档数量，以及生成答案的文档数量。
do_marginalize (bool, 可选) — 如果为 True，则通过对所有文档使用 torch.nn.functional.log_softmax 来对 logits 进行边际化。
reduce_loss (bool, 可选) — 只有在传递了 labels 时才相关。如果为 True，则使用 torch.Tensor.sum 操作来减少 NLL 损失。
kwargs (Dict[str, any], 可选, 默认为 {}) —— 过时字典，模型使用 generate() 函数时必须提供。

返回值

transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或 tuple(torch.FloatTensor)

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 语言模型损失。
logits (`torch.FloatTensor，形状为 `(batch_size, sequence_length, config.vocab_size)`） — 语言模型头的预测分数。该分数可能在所有文档上对所有词汇表标记进行边缘化。
doc_scores (`torch.FloatTensor，形状为 `(batch_size, config.n_docs)`） — 每个检索到的文档嵌入（参见`retrieved_doc_embeds`) 与 `question_encoder_last_hidden_state`之间的得分。
past_key_values (`List[torch.FloatTensor]，`可选`，仅在传递 `use_cache=True` 或当 `config.use_cache=True` 时返回) — 长度为 `config.n_layers` 的 `torch.FloatTensor` 列表，其中每个张量的形状为 `(2, batch_size, num_heads, sequence_length, embed_size_per_head)`。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
retrieved_doc_embeds (`torch.FloatTensor，形状为 `(batch_size, config.n_docs, hidden_size)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档。与 `question_encoder_last_hidden_state` 一起使用来计算 `doc_scores`。
retrieved_doc_ids (`torch.LongTensor，形状为 `(batch_size, config.n_docs)`，`可选`，在 `output_retrieved=True` 时返回) — 检索器检索的嵌入文档的索引。
context_input_ids (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的输入 input_ids。
context_attention_mask (torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length), 可选，在 output_retrieved=True 时返回) — 由检索器后处理的检索文档和问题编码器的 input_ids 的注意掩码。
question_encoder_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 问题编码器模型的池化输出的最后层输出的隐藏状态序列。
question_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

在每个层输出加上初始嵌入输出的问题编码器的隐藏状态。
question_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型生成器编码器的最后层输出的隐藏状态序列。
generator_enc_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(torch.FloatTensor), 可选，在 output_hidden_states=True 被传递或当 config.output_hidden_states=True）时返回 — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的元组（一个用于嵌入输出，一个用于每一层的输出）。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（一个用于每个层）。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_cross_attentions (tuple(torch.FloatTensor), 可选，在 output_attentions=True 被传递或当 config.output_attentions=True）时返回 — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的元组（每个层一个）。

交叉注意力权重，在注意软最大值之后，用于计算交叉注意头中的加权平均。

RagTokenForGeneration 前向方法，重写了__call__特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> from transformers import AutoTokenizer, RagRetriever, RagTokenForGeneration
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever)

>>> inputs = tokenizer("How many people live in Paris?", return_tensors="pt")
>>> targets = tokenizer(text_target="In Paris, there are 10 million people.", return_tensors="pt")
>>> input_ids = inputs["input_ids"]
>>> labels = targets["input_ids"]
>>> outputs = model(input_ids=input_ids, labels=labels)

>>> # or use retriever separately
>>> model = RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", use_dummy_dataset=True)
>>> # 1. Encode
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.detach().numpy(), return_tensors="pt")
>>> doc_scores = torch.bmm(
...     question_hidden_states.unsqueeze(1), docs_dict["retrieved_doc_embeds"].float().transpose(1, 2)
... ).squeeze(1)
>>> # 3. Forward to generator
>>> outputs = model(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=labels,
... )

>>> # or directly generate
>>> generated = model.generate(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
... )
>>> generated_string = tokenizer.batch_decode(generated, skip_special_tokens=True)

generate

< source >

( input_ids: Optional = None attention_mask: Optional = None context_input_ids: Optional = None context_attention_mask: Optional = None doc_scores: Optional = None n_docs: Optional = None generation_config: Optional = None prefix_allowed_tokens_fn: Callable = None logits_processor: Optional = [] stopping_criteria: Optional = [] **kwargs ) → torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

参数

input_ids （torch.LongTensor 形状为 (batch_size, sequence_length)，可选）- 作为生成提示的序列。如果没有传入 input_ids，则必须提供 context_input_ids。
attention_mask （torch.Tensor 形状为 (batch_size, sequence_length)，可选）- 用于避免在填充令牌索引上执行注意力的掩码。掩码值在 [0, 1] 之间：
- 对于 未掩码 的令牌为 1，
- 对于 已掩码 的令牌为 0。
什么是注意掩码？
context_input_ids （torch.LongTensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回）- 从检索到的文档和问题编码器的 input_ids 中由检索器处理的输入 ID。

如果模型未初始化为 retriever，则需要向前传递 context_input_ids。 context_input_ids 由 __call__() 返回。
context_attention_mask （形状为 (batch_size * config.n_docs, config.max_combined_length) 的 torch.LongTensor，可选，当 output_retrieved=True 时返回）— 通过检索器从检索到的文档和问题编码器 input_ids 后处理得到的注意力掩码。

如果模型没有初始化 retriever，则必须在前向传递中提供 context_input_ids。 context_input_ids 由 __call__() 返回。
doc_scores （形状为 (batch_size, config.n_docs) 的 torch.FloatTensor）— 每个检索到的文档嵌入（见 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之间的分数。

如果模型没有初始化 retriever，则必须在前向传递中提供 context_input_ids。 context_input_ids 由 __call__() 返回。
n_docs （int，可选，默认为 config.n_docs）— 要检索的文档数量和/或生成答案的文档数量。
generation_config (~generation.GenerationConfig, 可选) —— 用于生成调用基础参数化的生成配置。传递给 generate 且与 generation_config 属性匹配的 **kwargs 将覆盖它们。如果没有提供 generation_config，则将使用默认配置，其加载优先级如下：1) 从存在的话的 generation_config.json 模型文件；2) 从模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，其文档应被检查以参数化生成。
prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]], 可选) —— 如果提供，此函数将约束搜索仅允许每个步骤的令牌。如果没有提供，则不应用任何约束。此函数接受两个参数 inputs_ids 和批次 ID batch_id。它必须返回一个包含允许令牌的列表，这些令牌对应于上一步生成的令牌 inputs_ids 和批次 ID batch_id。此参数对于根据前缀约束的生成非常有用，如自回归实体检索中所述。
logits_processor (LogitsProcessorList, 可选) —— 自定义的 logits 处理器，它补充了从参数和模型配置构建的默认 logits 处理器。如果传递了一个已经使用参数或模型配置创建的 logit 处理器，将抛出错误。
stopping_criteria (StoppingCriteriaList, 可选) — 自定义停止标准，与由参数和模型配置构建的默认停止标准相辅相成。如果传递的停止标准已经是用参数或模型配置创建的，则会抛出错误。
kwargs (Dict[str, Any], 可选) — 对 generate_config 的即时参数化以及/或将被转发到模型 forward 函数的额外模型特定kwargs。

返回值

torch.LongTensor，形状为 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二个维度（序列长度）要么等于 max_length，要么由于 eos_token_id 而提前完成所有批次的长度更短。

实现RAG标记解码。

TensorFlow

隐藏TensorFlow内容

TFRagModel

类 transformers.TFRagModel

< source >

( config: Optional[PretrainedConfig] = None question_encoder: Optional[TFPreTrainedModel] = None generator: Optional[TFPreTrainedModel] = None retriever: Optional[RagRetriever] = None load_weight_prefix: Optional[str] = None **kwargs )

参数

config (RagConfig) — 模型配置类，包含所有模型参数。使用配置文件初始化时不会加载与模型关联的权重，只会加载配置。请参阅from_pretrained()方法加载模型权重。
question_encoder (TFPreTrainedModel) — 与retriever封装的faiss索引兼容的编码器模型。
generator (TFPreTrainedModel) — 在 RAG 架构中用作生成器的 seq2seq 模型。
retriever (RagRetriever) — 封装 faiss 索引的检索器，用于获取当前输入的上下文文档。

TFRagModel 的前进方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

RAG 是一个将问题编码器和一个生成器封装在内的 seq2seq 模型。在正向传播过程中，我们使用问题编码器编码输入，并将其传递给检索器以提取相关上下文文档。然后将文档附加到输入后面。这些上下文化的输入被传递到生成器。

问题编码器可以是任何 autoencoding 模型，最好使用 TFDPRQuestionEncoder，生成器可以是任何 seq2seq 模型，最好使用 TFBartForConditionalGeneration。

该模型可以初始化为 RagRetriever 以实现端到端生成，或者与检索器的输出结合使用分步处理——请参阅示例以获取更多细节。该模型与任何作为 question_encoder 的 autoencoding 模型以及任何带有语言模型头的 seq2seq 模型兼容，作为 generator。它已经与 TFDPRQuestionEncoder 作为 question_encoder 和 TFBartForConditionalGeneration 作为 generator 进行了测试。

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

此模型也是 Tensorflow 的 keras.Model 子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档以了解所有与常规使用和行为相关的事项。

该模型处于开发状态，因为它目前仅支持 eager-mode，可能无法以 SavedModel 格式导出。

调用

< source >

参数

input_ids （形状为 (batch_size, sequence_length) 的 tf.Tensor）— 输入序列标记的词汇索引。RagConfig，用于初始化模型，指定使用哪种生成器，同时也指定了一个兼容的生成器分词器。使用该分词器类来获取索引。
attention_mask （形状为 (batch_size, sequence_length)，可选）— 避免对填充标记索引执行注意力的掩码。掩码值在 [0, 1] 之间选择：
- 1 代表 未掩码 的标记，
- 0 代表掩码的标记。
什么是注意掩码？
encoder_outputs （tuple(tuple(tf.Tensor)），可选）— 包含 generator_enc_last_hidden_state（可选）、generator_enc_hidden_states（可选）、generator_enc_attentions（可选）。generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size) 是生成器编码器最后一层输出的隐藏状态序列。
learn more about this function
decoder_input_ids (tf.Tensor的大小为(batch_size, target_sequence_length)，可选) —— 用于生成任务。默认值为None，根据您使用的RAG实例的生成器模型指令进行构造。
decoder_attention_mask (torch.BoolTensor的大小为(batch_size, target_sequence_length)，可选) —— 默认行为：生成一个忽略decoder_input_ids中的填充token的tensor。默认还将使用因果掩码。
past_key_values (tuple(tuple(tf.Tensor))) —— 由两个元素组成：RAG模型的encoder_outputs（见encoder_outputs）和底层生成器的past_key_values。可以用于加速解码。past_key_values在解码时用于(RagTokenForGeneration)模型中。
doc_scores (tf.Tensor 形状为 (batch_size, config.n_docs)) — 每个检索到的文档嵌入（参见 retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的分数。如果模型没有被初始化为 retriever，则必须在正向传递中提供 doc_scores。可以通过 question_encoder_last_hidden_state 和 retrieved_doc_embeds 来计算 doc_scores，请参阅示例以获取更多信息。
context_input_ids (tf.Tensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回) — 由 retriever 对检索到的文档和问题编码器 input_ids 进行后处理后的输入 ID。
如果模型没有被初始化为 retriever，则必须在正向传递中提供 context_input_ids。context_input_ids 由 __call__() 返回。context_attention_mask （tf.Tensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回）：由 retriever 对检索到的文档和问题编码器 input_ids 进行后处理后的注意掩码。
如果模型没有被初始化为 retriever，则必须在正向传递中提供 context_attention_mask。context_attention_mask 由 __call__() 返回。
use_cache (bool, 可选，默认值为 True) — 如果设置为 True，将返回 past_key_values 的键值状态，并可用于加快解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多信息请参见返回的张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多信息请参见返回的张量中的 hidden_states。
output_retrieved(bool) — 是否返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。详细内容请参阅返回的张量。
return_dict(bool) — 是否用 TFRetrievAugLMOutput 替代普通元组返回。
n_docs(int, 可选，默认为 `config.n_docs`) — 获取和/或生成答案的文档数量。

返回值

transformers.models.rag.modeling_tf_rag.TFRetrievAugLMOutput 或 tuple(tf.Tensor)

一个 transformers.models.rag.modeling_tf_rag.TFRetrievAugLMOutput 或一个 `tf.Tensor` 的元组（如果传递了 `return_dict=False` 或 `config.return_dict=False`）包含不同配置(RagConfig)和输入下的不同元素。

logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数。分数可能是所有文档对所有词汇符号的边缘化。
past_key_values (List[tf.Tensor]，可选，当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 一个长度为 config.n_layers 的 `tf.Tensor` 列表，其中每个张量为形状 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
doc_scores (tf.Tensor 形状为 (batch_size, config.n_docs)) — 检索到的文档嵌入（见 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之间的分数。
retrieved_doc_embeds (tf.Tensor，形状为(batch_size, config.n_docs, hidden_size)，可选，当output_retrieved=True时返回) — 通过检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起使用，来计算doc_scores。
retrieved_doc_ids (tf.Tensor，形状为(batch_size, config.n_docs)，可选，当output_retrieved=True时返回) — 由检索器检索到的嵌入文档的索引。
context_input_ids (tf.Tensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 通过检索器从检索到的文档和问题编码器输入ids后处理得到的输入ids。
context_attention_mask (tf.Tensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 通过检索器从检索到的文档和问题编码器input_ids后处理得到的注意力掩码。
question_encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型池化输出后问题编码器最后一层的隐藏状态序列。
question_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

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

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型生成器编码器最后一层的隐藏状态序列。
generator_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。

TFRagModel 的前进方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> from transformers import AutoTokenizer, RagRetriever, TFRagModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-base")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-base", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = TFRagModel.from_pretrained("facebook/rag-token-base", retriever=retriever, from_pt=True)

>>> input_dict = tokenizer.prepare_seq2seq_batch(
...     "How many people live in Paris?", "In Paris, there are 10 million people.", return_tensors="tf"
... )
>>> input_ids = input_dict["input_ids"]
>>> outputs = model(input_ids)

TFRagSequenceForGeneration

类 transformers.TFRagSequenceForGeneration

< 源代码 >

( config: Optional[PretrainedConfig] = None question_encoder: Optional[TFPreTrainedModel] = None generator: Optional[TFPreTrainedModel] = None retriever: Optional[RagRetriever] = None **kwargs )

参数

config (RagConfig) — 包含所有模型参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。请查看from_pretrained() 方法以加载模型权重。
question_encoder (TFPreTrainedModel) — 一个与retriever内封装的faiss索引兼容的编码器模型。
generator (TFPreTrainedModel) — 在RAG架构中作为生成器的seq2seq模型。
retriever (RagRetriever) — 一个封装用于查询以获取当前输入上下文文档的faiss索引的检索类。

TFRagSequenceForGeneration 的正向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

TF RAG-sequence 模型实现。它在正向传递中执行 RAG-sequence 特定的边缘化。

问题编码器可以是任何 autoencoding 模型，最好使用 TFDPRQuestionEncoder，生成器可以是任何 seq2seq 模型，最好使用 TFBartForConditionalGeneration。

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

此模型也是 Tensorflow 的 keras.Model 子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档以了解所有与常规使用和行为相关的事项。

该模型处于开发状态，因为它目前仅支持 eager-mode，可能无法以 SavedModel 格式导出。

调用

< 源 >

( input_ids: TFModelInputType 或 None = None attention_mask: np.ndarray 或 tf.Tensor 或 None = None decoder_input_ids: np.ndarray 或 tf.Tensor 或 None = None decoder_attention_mask: np.ndarray 或 tf.Tensor 或 None = None encoder_outputs: np.ndarray 或 tf.Tensor 或 None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None doc_scores: np.ndarray 或 tf.Tensor 或 None = None context_input_ids: np.ndarray 或 tf.Tensor 或 None = None context_attention_mask: np.ndarray 或 tf.Tensor 或 None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None output_retrieved: Optional[bool] = None n_docs: Optional[int] = None exclude_bos_score: Optional[bool] = None labels: np.ndarray 或 tf.Tensor 或 None = None reduce_loss: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或 tuple(tf.Tensor)

参数

input_ids (tf.Tensor 形状为 (batch_size, sequence_length)) — 词库中输入序列标记的索引。用于初始化模型的 RagConfig 指定了要使用的生成器，它还指定了兼容的生成器标记器。使用该标记器类来获取索引。
attention_mask (tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。选择的掩码值在 [0, 1] 之间：
- 1 代表未进行掩码的标记，
- 0 代表进行掩码的标记。
什么是注意力掩码？
encoder_outputs (tuple(tuple(tf.Tensor)，可选) — 元组由 (generator_enc_last_hidden_state，可选: generator_enc_hidden_states，可选: generator_enc_attentions) 组成。 generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size) 是生成器编码器的最后层输出的隐藏状态序列。
在解码过程中由 (TFRagModel) 模型使用。
decoder_input_ids (tf.Tensor 形状 (batch_size, target_sequence_length)，可选) — 生成任务中提供。默认为 None，根据您在 RAG 实例中使用的生成模型说明进行构建。
decoder_attention_mask (torch.BoolTensor 形状 (batch_size, target_sequence_length)，可选) — 默认行为：在 decoder_input_ids 中忽略填充 token。默认还会使用因果掩码。
past_key_values (tuple(tuple(tf.Tensor))) — 元组包含两个元素：RAG 模型的 encoder_outputs（见 encoder_outputs）和底层生成器的 past_key_values。可用于加速解码。在解码期间，(RagTokenForGeneration) 模型使用 past_key_values。
doc_scores （形状为 (batch_size, config.n_docs) 的 tf.Tensor）—检索到的文档嵌入（参见 retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的得分。如果模型未预先用 retriever 初始化，则必须在前进传递期间提供 doc_scores。 doc_scores 可以通过 question_encoder_last_hidden_state 和 retrieved_doc_embeds 来计算，更多详细信息请参阅示例。
context_input_ids （形状为 (batch_size * config.n_docs, config.max_combined_length) 的 tf.Tensor，可选，当 output_retrieved=True 时返回）—由检索器从检索到的文档和问题编码器的 input_ids 中处理后的输入 IDs。

如果模型未使用 retriever 初始化，则必须在前进传递期间提供 context_input_ids。 context_input_ids 由 __call__() 返回。 context_attention_mask （形状为 (batch_size * config.n_docs, config.max_combined_length) 的 tf.Tensor，可选，当 output_retrieved=True 时返回）: 由检索器从检索到的文档和问题编码器的 input_ids 中处理后的注意力掩码。

如果模型未使用 retriever 初始化，则必须在前进传递期间提供 context_attention_mask。《code>context_attention_mask 由 __call__() 返回。
use_cache（《布尔值》，《可选》，默认为True）—— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
output_attentions（《布尔值》，《可选》）—— 是否返回所有关注层的关注张量。有关更多详细信息，请参阅返回的张量下的attentions。
output_hidden_states（《布尔值》，《可选》）—— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
output_retrieved(bool，可选) — 是否返回 retrieved_doc_embeds，retrieved_doc_ids，context_input_ids 及 context_attention_mask。详见返回的张量以获取更多详细信息。
return_dict （可选）— 是否返回 TFRetrievAugLMOutput 而非普通元组。
n_docs（可选，默认为 `config.n_docs`）— 要检索和/或为生成答案的文档数。
exclude_bos_score（可选）— 只有在传递 labels 时才相关。如果为 True，则在计算损失时将 BOS 标记的分数忽略。
labels （tf.Tensor 或 shape 为 (batch_size, sequence_length) 的 np.ndarray，可选） — 按照Rag-Sequence模型公式计算交叉熵分类损失所用的标签，详见https://arxiv.org/pdf/2005.11401.pdf的第2.1节，了解Rag-Sequence公式的详细信息。索引应在[0, ..., config.vocab_size - 1]范围内。
reduce_loss（bool，可选） — 只有当传递了labels时才相关。如果True，则使用tf.Tensor.sum操作减少NLL损失。
kwargs（Dict[str, any]，可选，默认为 {}） — 旧版字典，模型使用 generate() 函数时所需的。

返回值

transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或 tuple(tf.Tensor)

transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或一个由 tf.Tensor 组成的元组（如果传递了 return_dict=False 或当 config.return_dict=False），其中包含的各种元素取决于配置（RagConfig）和输入。

loss（当提供labels时返回，可选， shape 为 (1,)的 tf.Tensor） — 语言模型损失。
logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数。分数可能是所有文档对所有词汇符号的边缘化。
past_key_values (List[tf.Tensor]，可选，当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 一个长度为 config.n_layers 的 `tf.Tensor` 列表，其中每个张量为形状 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
doc_scores (tf.Tensor 形状为 (batch_size, config.n_docs)) — 检索到的文档嵌入（见 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之间的分数。
retrieved_doc_embeds (tf.Tensor，形状为(batch_size, config.n_docs, hidden_size)，可选，当output_retrieved=True时返回) — 通过检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起使用，来计算doc_scores。
retrieved_doc_ids（当 output_retrieved=True 时返回，可选， shape 为 (batch_size, config.n_docs)的 tf.Tensor (int32)） — 被检索器检索到的嵌入文档的索引。
context_input_ids（当 output_retrieved=True 时返回，可选， shape 为 (batch_size * config.n_docs, config.max_combined_length)的 tf.Tensor (int32)） — 通过检索器从检索到的文档和问题编码器的input_ids进行后处理得到的输入id。
context_attention_mask （tf.Tensor （int32）形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回） — 由检索器来源于检索到的文档和问题编码器 input_ids 的后处理的注意掩码。
question_encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型池化输出后问题编码器最后一层的隐藏状态序列。
question_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

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

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型生成器编码器最后一层的隐藏状态序列。
generator_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。

TFRagSequenceForGeneration 的正向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> from transformers import AutoTokenizer, RagRetriever, TFRagSequenceForGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-sequence-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-sequence-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = TFRagSequenceForGeneration.from_pretrained(
...     "facebook/rag-sequence-nq", retriever=retriever, from_pt=True
... )

>>> input_dict = tokenizer.prepare_seq2seq_batch(
...     "How many people live in Paris?", "In Paris, there are 10 million people.", return_tensors="tf"
... )
>>> outputs = model(input_dict, output_retrieved=True)

>>> # or use retriever separately
>>> # 1. Encode
>>> input_ids = input_dict["input_ids"]
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.numpy(), return_tensors="tf")
>>> doc_scores = tf.squeeze(
...     tf.matmul(
...         tf.expand_dims(question_hidden_states, axis=1), docs_dict["retrieved_doc_embeds"], transpose_b=True
...     ),
...     axis=1,
... )
>>> # 3. Forward to generator
>>> outputs = model(
...     inputs=None,
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=input_dict["labels"],
... )

>>> # or directly generate
>>> generated = model.generate(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
... )
>>> generated_string = tokenizer.batch_decode(generated, skip_special_tokens=True)

generate

< 原始代码 >

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None context_input_ids = None context_attention_mask = None doc_scores = None do_deduplication = None num_return_sequences = None num_beams = None n_docs = None **model_kwargs ) → tf.Tensor 形状为 (batch_size * num_return_sequences, sequence_length)

参数

input_ids （形状为(batch_size, sequence_length)的tf.Tensor，可选） — 用于生成的提示序列。如果未传入input_ids，则必须提供context_input_ids。
attention_mask （形状为(batch_size, sequence_length)的tf.Tensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：- 1表示未掩码的标记，- 0表示掩码的标记。什么是注意力掩码？
context_input_ids （形状为(batch_size * config.n_docs, config.max_combined_length)的tf.Tensor，可选，在output_retrieved=True时返回） — 从检索的文章和问题编码器输入_ids中通过检索器后处理的输入 IDs。
context_attention_mask （tf.Tensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回） — 从检索到的文档和问题编码器 input_ids 后处理得到的注意力掩码。如果模型未初始化 retriever 或未提供 input_ids，则在正向传递时必须提供 context_input_ids 和 context_attention_mask。它们由 __call__() 返回。
doc_scores （tf.Tensor 形状为 (batch_size, config.n_docs)） — 每个检索到的文档嵌入（见 retrieved_doc_embeds）与 question_encoder_last_hidden_state 之间的分数。如果模型未初始化 retriever 或未提供 input_ids，则在正向传递时必须提供 doc_scores。doc_scores 由 __call__() 返回。
do_deduplication （bool，可选） — 是否对给定输入的不同上下文文档的生成进行去重。使用分布式后端训练时必须设置为 False。
num_return_sequences(int，可选，默认为1) — 每个批次的元素生成的独立返回序列数。请注意这不是我们传递给 generator 的 [generate()](/docs/transformers/v4.44.0/en/main_classes/text_generation#transformers.GenerationMixin.generate) 函数的值，在那里我们将 num_return_sequences 设置为 num_beams。
num_beams(int，可选，默认为1) — 束搜索的束宽。1表示没有束搜索。
n_docs(int，可选，默认为 config.n_docs) — 获取和/或生成答案的文档数。
kwargs (Dict[str, Any], optional) — 额外的kwargs将被传递到generate()

返回值

tf.Tensor 的形状为 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二个维度（序列长度）可能等于 max_length 或更短，如果所有批次因 eos_token_id 而提前完成。

实现RAG序列的“彻底”解码。阅读generate() 文档了解更多关于如何设置其他生成输入参数的信息

TFRagTokenForGeneration

class transformers.TFRagTokenForGeneration

< source >

( config: Optional[PretrainedConfig] = None question_encoder: Optional[TFPreTrainedModel] = None generator: Optional[TFPreTrainedModel] = None retriever: Optional[RagRetriever] = None **kwargs )

参数

config (RagConfig) —— 包含模型所有参数的模型配置类。使用配置文件初始化时不会加载模型相关的权重，只有配置。请查看 from_pretrained() 方法以加载模型权重。
question_encoder (TFPreTrainedModel) —— 与retriever封装的faiss索引兼容的编码器模型。
generator (TFPreTrainedModel) —— 在RAG架构中用作生成器的seq2seq模型。
retriever (RagRetriever) —— 包含查询以获取当前输入的上下文文档的faiss索引的检索器类。

TFRagTokenForGeneration 前向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

TF RAG-token 模型实现。在前向传递中执行 RAG-token 特定的边缘化。

问题编码器可以是任何 autoencoding 模型，最好使用 TFDPRQuestionEncoder，生成器可以是任何 seq2seq 模型，最好使用 TFBartForConditionalGeneration。

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

此模型也是 Tensorflow 的 keras.Model 子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档以了解所有与常规使用和行为相关的事项。

该模型处于开发状态，因为它目前仅支持 eager-mode，可能无法以 SavedModel 格式导出。

调用

< source >

参数

input_ids (tf.Tensor 的形状为 (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。用于初始化模型的 RagConfig 指定要使用的生成器，同时也指定一个兼容的生成器分词器。使用该分词器类来获取索引。
attention_mask (tf.Tensor 的形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在 [0, 1] 中选取：
- 1 对于未掩码的标记，
- 0 对于掩码的标记。
注意掩码是什么？
encoder_outputs (tuple(tuple(tf.Tensor)，可选) — 包含 (generator_enc_last_hidden_state，可选: generator_enc_hidden_states，可选: generator_enc_attentions)。 generator_enc_last_hidden_state 的形状为 (batch_size, n_docs * sequence_length, hidden_size) 是生成器编码器最后层的隐藏状态序列。

在 TFRagModel 模型解码时使用。
decoder_input_ids (tf.Tensor of shape (batch_size, target_sequence_length), optional) — Provide for generation tasks. The default is None, construct according to the instructions of the generator model used with RAG instances.
decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — Default behavior: generates a tensor that ignores pad tokens in decoder_input_ids. The causal mask is also used by default.
past_key_values (tuple(tuple(tf.Tensor))) — The tuple consists of two elements: encoder_outputs of the RAG model (see encoder_outputs) and past_key_values of the underlying generator. Can be used to speed up decoding. past_key_values are used in the (RagTokenForGeneration) model during decoding.
doc_scores（《tf.Tensor》形状为(batch_size, config.n_docs)）——每个检索到的文档嵌入（参看retrieved_doc_embeds）与question_encoder_last_hidden_state之间的分数。如果模型未通过retriever初始化，那么必须为前向传递提供doc_scores。doc_scores可以通过question_encoder_last_hidden_state和retrieved_doc_embeds计算，更多信息请参阅示例。
context_input_ids（《tf.Tensor》形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回）——由检索器从检索到的文档和问题编码器 input_ids 后处理得到的输入 IDs。

如果模型未通过retriever初始化，则必须为前向传递提供 `context_input_ids。由 __call__() 返回。
context_attention_mask（《tf.Tensor》形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回）：由检索器从检索到的文档和问题编码器 input_ids 后处理得到的注意力掩码。
如果模型未通过retriever初始化，则必须为前向传递提供context_attention_mask。由 __call__() 返回。
use_cache（bool，可选，默认为True）——如果设置为True，将返回 past_key_values键值状态，并可用来加速解码（见past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关返回张量中的更多详细信息，请参阅《attentions》。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关返回张量中的更多详细信息，请参阅《hidden_states》。
output_retrieved(bool, 可选) — 是否返回retrieved_doc_embeds，retrieved_doc_ids，context_input_ids和context_attention_mask。有关返回张量的更多详细信息，请参阅。
return_dict (bool, 可选) — 是否返回一个 TFRetrievAugLMOutput 而不是平凡元组。
n_docs (int, 可选, 默认为 `config.n_docs`) — 获取和/或生成答案的文档数量。
do_marginalize (bool, 可选) — 如果为 True，则通过对所有文档使用 torch.nn.functional.log_softmax 来归一化得到最终概率。
labels (tf.Tensor 或 np.ndarray 形状为 (batch_size, sequence_length)，为可选参数) — 用于按 Rag-Token 模型公式计算交叉熵分类损失的标签。见 https://arxiv.org/pdf/2005.11401.pdf 的第 2.1 节，了解 Rag-Token 公式的详细信息。索引应在 [0, ..., config.vocab_size - 1] 内。
reduce_loss (bool，为可选参数) — 只有在传递了 labels 时相关。如果设置为 True，将使用 tf.Tensor.sum 操作来减少 NLL 损失。
kwargs (Dict[str, any]，为可选参数，默认为 {}) — 旧式字典，模型使用 generate() 函数需要此字典。

返回值

transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或 tuple(tf.Tensor)

loss（当提供labels时返回，可选， shape 为 (1,)的 tf.Tensor） — 语言模型损失。
logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数。分数可能是所有文档对所有词汇符号的边缘化。
past_key_values (List[tf.Tensor]，可选，当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 一个长度为 config.n_layers 的 `tf.Tensor` 列表，其中每个张量为形状 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

包含解码器预计算隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加快顺序解码。
doc_scores (tf.Tensor 形状为 (batch_size, config.n_docs)) — 检索到的文档嵌入（见 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之间的分数。
retrieved_doc_embeds (tf.Tensor，形状为(batch_size, config.n_docs, hidden_size)，可选，当output_retrieved=True时返回) — 通过检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起使用，来计算doc_scores。
retrieved_doc_ids（当 output_retrieved=True 时返回，可选， shape 为 (batch_size, config.n_docs)的 tf.Tensor (int32)） — 被检索器检索到的嵌入文档的索引。
context_input_ids（当 output_retrieved=True 时返回，可选， shape 为 (batch_size * config.n_docs, config.max_combined_length)的 tf.Tensor (int32)） — 通过检索器从检索到的文档和问题编码器的input_ids进行后处理得到的输入id。
context_attention_mask （tf.Tensor （int32）形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，当 output_retrieved=True 时返回） — 由检索器来源于检索到的文档和问题编码器 input_ids 的后处理的注意掩码。
question_encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型池化输出后问题编码器最后一层的隐藏状态序列。
question_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

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

问题编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_enc_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型生成器编码器最后一层的隐藏状态序列。
generator_enc_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器编码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_enc_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器编码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。
generator_dec_hidden_states (tuple(tf.Tensor)，可选，当output_hidden_states=True传递或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组(一个用于嵌入输出，一个用于每个层的输出)。

生成器解码器的每个层输出加上初始嵌入输出的隐藏状态。
generator_dec_attentions (tuple(tf.Tensor)，可选，当output_attentions=True传递或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor的元组(每个层一个)。

生成器解码器的注意权重，在注意软最大值之后，用于计算自注意头中的加权平均。

TFRagTokenForGeneration 前向方法，重写了 __call__ 特殊方法。

尽管需要在函数内部定义向前传递的配方，但应该在后调用 Module 实例而不是这个，因为前者负责运行预和后处理步骤，而后者静默忽略它们。

示例

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, RagRetriever, TFRagTokenForGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/rag-token-nq")
>>> retriever = RagRetriever.from_pretrained(
...     "facebook/rag-token-nq", index_name="exact", use_dummy_dataset=True
... )
>>> # initialize with RagRetriever to do everything in one forward call
>>> model = TFRagTokenForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever, from_pt=True)

>>> input_dict = tokenizer.prepare_seq2seq_batch(
...     "How many people live in Paris?", "In Paris, there are 10 million people.", return_tensors="tf"
... )
>>> outputs = model(input_dict, output_retrieved=True)

>>> # or use retriever separately
>>> # 1. Encode
>>> input_ids = input_dict["input_ids"]
>>> question_hidden_states = model.question_encoder(input_ids)[0]
>>> # 2. Retrieve
>>> docs_dict = retriever(input_ids.numpy(), question_hidden_states.numpy(), return_tensors="tf")
>>> doc_scores = tf.squeeze(
...     tf.matmul(
...         tf.expand_dims(question_hidden_states, axis=1), docs_dict["retrieved_doc_embeds"], transpose_b=True
...     ),
...     axis=1,
... )
>>> # 3. Forward to generator
>>> outputs = model(
...     inputs=None,
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
...     decoder_input_ids=input_dict["labels"],
... )

>>> # or directly generate
>>> generated = model.generate(
...     context_input_ids=docs_dict["context_input_ids"],
...     context_attention_mask=docs_dict["context_attention_mask"],
...     doc_scores=doc_scores,
... )
>>> generated_string = tokenizer.batch_decode(generated, skip_special_tokens=True)

generate

< 源代码 >

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None context_input_ids = None context_attention_mask = None doc_scores = None n_docs = None generation_config = None logits_processor = [] **kwargs ) → tf.Tensor of shape (batch_size * num_return_sequences, sequence_length)

参数

input_ids (tf.Tensor of shape (batch_size, sequence_length), 可选) — 用于生成的提示序列。如果没有提供 input_ids，则必须提供 context_input_ids。
attention_mask (tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 代表未被掩码的token，
- 0 代表被掩码的token。
什么是注意力掩码？
context_input_ids (tf.Tensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，在 output_retrieved=True 时返回) — 由检索进程从检索到的文档和问题编码器 input_ids 后处理得到的输入ID。

如果没有使用 retriever 初始化模型，必须提供 context_input_ids 以供前向传递。通过 __call__() 返回 context_input_ids。
context_attention_mask (tf.Tensor 形状为 (batch_size * config.n_docs, config.max_combined_length)，可选，在 output_retrieved=True 时返回) — 由检索进程从检索到的文档和问题编码器 input_ids 后处理得到的注意力掩码。

如果没有使用 retriever 初始化模型，必须提供 context_input_ids 以供前向传递。通过 __call__() 返回 context_input_ids。
doc_scores (tf.Tensor形状为(batch_size, config.n_docs)) — 每个检索到的文档嵌入（参见retrieved_doc_embeds）与question_encoder_last_hidden_state之间的分数。

如果模型未使用retriever初始化，必须在正向传递中提供一个context_input_ids。context_input_ids由__call__()返回。
n_docs (int，可选，默认为config.n_docs） — 要检索和/或为生成答案的文档数量。
generation_config (~generation.GenerationConfig，可选） — 用于生成调用作为基础参数化的生成配置。传递给generate的**kwargs与generation_config的属性匹配并将覆盖它们。如果没有提供generation_config，将使用默认值，其加载优先级如下：1）从存在的generation_config.json模型文件中获取；2）从模型配置中获取。请注意，未指定的参数将继承GenerationConfig的默认值，其文档应进行检查以参数化生成。
logits_processor（《TFLogitsProcessorList》，可选）——自定义的logit处理器，补充了由参数和模型配置构建的默认logit处理器。如果传入了一个已经用参数或模型配置创建的logit处理器，将抛出错误。
kwargs（《Any排字典》可选）——对《generate_config》进行临时参数化，或者将补充模型特定关键字参数传递给模型的《forward》函数。

返回值

tf.Tensor 的形状为 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二个维度（序列长度）要么等于 max_length，要么由于 eos_token_id 而提前完成所有批次的长度更短。

实现TFRAG令牌解码。

< > 在GitHub上更新

←Qwen2MoE REALM→