Transformers 4.37 中文文档（五十三）（4）

Transformers 4.37 中文文档（五十三）（3）https://developer.aliyun.com/article/1565359

RagTokenForGeneration

class transformers.RagTokenForGeneration

<来源>

( config: Optional = None question_encoder: Optional = None generator: Optional = None retriever: Optional = None **kwargs )

参数

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

RagTokenForGeneration 前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

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

RAG 是一个 seq2seq 模型，封装了两个核心组件：一个问题编码器和一个生成器。在前向传递期间，我们使用问题编码器对输入进行编码，并将其传递给检索器以提取相关的上下文文档。然后将文档添加到输入中。这样的上下文化输入被传递给生成器。

问题编码器可以是任何自动编码模型，最好是 DPRQuestionEncoder，生成器可以是任何seq2seq模型，最好是 BartForConditionalGeneration。

该模型可以使用 RagRetriever 进行端到端生成，也可以与检索器的输出结合在多个步骤中使用—有关更多详细信息，请参见示例。该模型与任何自动编码模型兼容，作为question_encoder，以及任何带有语言模型头的seq2seq模型，作为generator。已经使用 DPRQuestionEncoder 作为question_encoder，以及 BartForConditionalGeneration 或 T5ForConditionalGeneration 作为generator进行测试。

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

该模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( 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 context_input_ids: Optional = None context_attention_mask: Optional = None doc_scores: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_retrieved: Optional = None do_marginalize: Optional = None reduce_loss: Optional = None labels: Optional = None n_docs: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput or 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）。形状为(batch_size, n_docs * sequence_length, hidden_size)的generator_enc_last_hidden_state是生成器编码器最后一层的隐藏状态序列。
  在解码期间，由(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 of shape (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 (torch.LongTensor of shape (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 of shape (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“) — 要检索的文档数量和/或要生成答案的文档数量。
  
• do_marginalize (bool, 可选) — 如果为True，则通过使用torch.nn.functional.log_softmax对所有文档进行边际化。
  
• 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 of shape (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)。
  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  
• retrieved_doc_embeds（形状为(batch_size, config.n_docs, hidden_size)的torch.FloatTensor，可选，当output_retrieved=True时返回）- 检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起用于计算doc_scores。
  
• retrieved_doc_ids（形状为(batch_size, config.n_docs)的torch.LongTensor，可选，当output_retrieved=True时返回）- 检索器检索到的嵌入文档的索引。
  
• context_input_ids（形状为(batch_size * config.n_docs, config.max_combined_length)的torch.LongTensor，可选，当output_retrieved=True时返回）- 从检索到的文档和问题编码器输入 id 经过后处理得到的输入 id。
  
• context_attention_mask（形状为(batch_size * config.n_docs, config.max_combined_length)的torch.LongTensor，可选，当output_retrieved=True时返回）- 从检索到的文档和问题编码器input_ids经过后处理得到的注意力掩码。
  
• question_encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 问题编码器最后一层输出的隐藏状态序列，模型的汇总输出。
  
• 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元组（每一层一个）。
  问题编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• 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（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每一层一个）。
  生成器编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• 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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  生成器解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• generator_cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  生成器解码器的交叉注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  

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

<来源>

( 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 ) → export const metadata = 'undefined';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 (torch.LongTensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 从检索到的文档和问题编码器input_ids后处理得到的注意力掩码。
  如果模型未使用retriever进行初始化，则必须在前向传递中提供context_input_ids。context_input_ids由__call__()返回。
  
• doc_scores (torch.FloatTensor，形状为(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, optional) — 用作生成调用的基本参数化的生成配置。传递给生成的**kwargs匹配generation_config的属性将覆盖它们。如果未提供generation_config，将使用默认配置，其加载优先级如下：1）从generation_config.json模型文件中，如果存在；2）从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以对生成进行参数化。
  
• prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]], optional) — 如果提供，此函数将每一步的 beam 搜索限制为仅允许的标记。如果未提供，则不应用约束。此函数接受 2 个参数inputs_ids和批次 IDbatch_id。它必须返回一个列表，其中包含下一代步的允许标记，条件是先前生成的标记inputs_ids和批次 IDbatch_id。此参数对于受前缀约束的生成很有用，如自回归实体检索中所述。
  
• logits_processor (LogitsProcessorList, optional) — 自定义 logits 处理器，补充从参数和模型配置构建的默认 logits 处理器。如果传递的 logit 处理器已经使用参数或模型配置创建，则会引发错误。
  
• stopping_criteria (StoppingCriteriaList, optional) — 自定义停止标准，补充从参数和模型配置构建的默认停止标准。如果传递的停止标准已经使用参数或模型配置创建，则会引发错误。
  
• kwargs (Dict[str, Any], optional) — generate_config的特定参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。
  

返回

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

生成的序列。第二维（sequence_length）要么等于max_length，要么如果所有批次由于eos_token_id而提前完成，则要短。

实现了 RAG 标记解码。

TensorFlow 隐藏了 TensorFlow 内容

TFRagModel

class transformers.TFRagModel

<来源>

( 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 是一个序列到序列模型，包含两个核心组件：一个问题编码器和一个生成器。在前向传递过程中，我们使用问题编码器对输入进行编码，并将其传递给检索器以提取相关的上下文文档。然后将这些文档添加到输入之前。这样的上下文化输入被传递给生成器。

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

该模型可以使用 RagRetriever 进行端到端生成初始化，或者与检索器的输出结合在多个步骤中使用—请参阅更多详细信息的示例。该模型兼容任何自动编码模型作为question_encoder，以及任何带有语言模型头的seq2seq模型作为generator。已经测试过使用 TFDPRQuestionEncoder 作为question_encoder和 TFBartForConditionalGeneration 作为generator。

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

该模型也是一个 Tensorflow tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

该模型目前仅在急切模式下完全支持，并且可能无法以 SavedModel 格式导出。

call

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Tuple[Tuple[Union[np.ndarray, tf.Tensor]]] | None = 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: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None output_retrieved: bool | None = None n_docs: int | None = None return_dict: bool | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.models.rag.modeling_tf_rag.TFRetrievAugLMOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的tf.Tensor） — 词汇表中输入序列标记的索引。用于初始化模型的 RagConfig 指定要使用的生成器，还指定了兼容的生成器分词器。使用该分词器类获取索引。
  
• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

• 1 表示未被“掩码”（masked）的标记，
  
• 对于被“掩码”（masked）的标记。
  

• 什么是注意力掩码？
  
• encoder_outputs（元组（元组（tf.Tensor）的形状，可选） — 元组由（generator_enc_last_hidden_state，可选：generator_enc_hidden_states，可选：generator_enc_attentions）组成。形状为(batch_size, n_docs * sequence_length, hidden_size)的generator_enc_last_hidden_state是生成器编码器最后一层的隐藏状态序列。
  在解码过程中由（TFRagModel）模型使用。
  
• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选） — 用于生成任务。默认为None，根据您正在使用的 RAG 实例的生成器模型的说明进行构造。
  
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。
  
• past_key_values（tuple(tuple(tf.Tensor))）- 元组包含两个元素：RAG 模型的encoder_outputs（参见encoder_outputs）和基础生成器的past_key_values。可用于加速解码。在解码期间，past_key_values在（RagTokenForGeneration）模型中使用。
  
• 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后处理的输入 ID。
  如果模型未使用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。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（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）- 语言建模头的预测分数。该分数可能针对每个词汇标记在所有文档上进行边缘化。
  
• 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)。
  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  
• 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)，optional，当output_retrieved=True时返回) — 检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起用于计算doc_scores。
  
• retrieved_doc_ids (tf.Tensor，形状为(batch_size, config.n_docs)，optional，当output_retrieved=True时返回) — 检索器检索到的嵌入文档的索引。
  
• context_input_ids (tf.Tensor，形状为(batch_size * config.n_docs, config.max_combined_length)，optional，当output_retrieved=True时返回) — 从检索到的文档和问题编码器输入 ids 后处理得到的输入 ids。
  
• context_attention_mask (tf.Tensor，形状为(batch_size * config.n_docs, config.max_combined_length)，optional，当output_retrieved=True时返回) — 从检索到的文档和问题编码器input_ids后处理得到的注意力掩码。
  
• question_encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 问题编码器池化输出模型最后一层的隐藏状态序列。
  
• question_enc_hidden_states (tuple(tf.Tensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每个层的输出）。
  问题编码器在每一层输出的隐藏状态以及初始嵌入输出。
  
• question_enc_attentions (tuple(tf.Tensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
  问题编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• generator_enc_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型生成器编码器最后一层的隐藏状态序列。
  
• generator_enc_hidden_states (tuple(tf.Tensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每个层的输出）。
  生成器编码器在每一层输出的隐藏状态以及初始嵌入输出。
  
• generator_enc_attentions (tuple(tf.Tensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
  生成器编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• generator_dec_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每个层的输出）。
  生成器解码器在每一层输出的隐藏状态以及初始嵌入输出。
  
• generator_dec_attentions (tuple(tf.Tensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
  生成器解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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)

Transformers 4.37 中文文档（五十三）（5）https://developer.aliyun.com/article/1565362