Transformers 4.37 中文文档（五十三）（3）-阿里云开发者社区

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

RagModel

`class transformers.RagModel`

( 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 索引，用于获取当前输入的上下文文档。

RagModel 的前向方法覆盖了__call__特殊方法。

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

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 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 ) → export const metadata = 'undefined';transformers.models.rag.modeling_rag.RetrievAugLMOutput or tuple(torch.FloatTensor)

参数

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

对于未被masked的标记，值为 1，
对于被masked的标记，值为 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 (torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 为生成任务提供。默认为None，根据您使用的 RAG 实例的生成器模型的说明构建。
decoder_attention_mask (torch.BoolTensor，形状为(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，形状为(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，形状为(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“) — 要检索的文档数量和/或要生成答案的文档数量。

返回值

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)。
包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
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，形状为(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元组（每层一个）。
问题编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
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元组（每层一个）。
生成器编码器的注意力权重，在注意力 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)，可选，当传递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 之后，用于计算交叉注意力头中的加权平均值。

RagModel 的前向方法，覆盖了__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

`class transformers.RagSequenceForGeneration`

<来源>

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

参数

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

RagSequenceForGeneration 的前向方法，覆盖了__call__特殊方法。

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

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 exclude_bos_score: 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]中：

对于被“masked”掉的标记为 1，
对于被masked掉的标记。

什么是注意力掩码？
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（形状为(batch_size, config.n_docs)的torch.FloatTensor）- 每个检索到的文档嵌入（参见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，形状为(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_attention_mask。context_attention_mask由__call__()返回。
use_cache（bool，可选，默认为True）- 如果设置为True，则返回past_key_values键值状态，可用于加速解码（请参见past_key_values）。
output_attentions（布尔值，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量中的attentions。
output_hidden_states（布尔值，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量中的hidden_states。
output_retrieved（布尔值，可选）- 是否返回retrieved_doc_embeds、retrieved_doc_ids、context_input_ids和context_attention_mask。有关更多详细信息，请参见返回的张量。
n_docs（int，可选，默认为config.n_docs）- 要检索的文档数量和/或要生成答案的文档数量。
exclude_bos_score（布尔值，可选）- 仅在传递了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（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 语言建模损失。
logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数。该分数可能针对每个词汇标记在所有文档上进行边缘化。
doc_scores（形状为(batch_size, config.n_docs)的torch.FloatTensor）- 每个检索到的文档嵌入（参见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（形状为(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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
生成器解码器的交叉注意力权重，在注意力 softmax 之后使用，用于计算交叉注意力头中的加权平均值。

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

<来源>

( input_ids: Optional = None attention_mask: Optional = None context_input_ids: Optional = None context_attention_mask: Optional = None doc_scores: Optional = None do_deduplication: Optional = None num_return_sequences: Optional = None num_beams: Optional = None n_docs: Optional = None **model_kwargs ) → export const metadata = 'undefined';torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用作生成提示的序列。如果未传递input_ids，则必须提供context_input_ids。
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

对于未被掩盖的标记为 1，
对于被掩盖的标记为 0。

什么是注意力掩码？
context_input_ids (torch.LongTensor of shape (batch_size * config.n_docs, config.max_combined_length), optional, 在output_retrieved=True时返回) — 从检索到的文档和问题编码器 input_ids 经过后处理得到的输入 ID。
context_attention_mask (torch.LongTensor of shape (batch_size * config.n_docs, config.max_combined_length), optional, 在output_retrieved=True时返回) — 从检索到的文档和问题编码器input_ids经过后处理得到的注意力掩码。
如果模型未初始化为retriever或未给出input_ids，则必须在前向传递中提供context_input_ids和context_attention_mask。它们由__call__()返回。
doc_scores (torch.FloatTensor of shape (batch_size, config.n_docs)) — 每个检索到的文档嵌入（见retrieved_doc_embeds）与question_encoder_last_hidden_state之间的得分。
如果模型未初始化为retriever或未给出input_ids，则必须在前向传递中提供doc_scores。doc_scores由__call__()返回。
do_deduplication (bool, optional) — 是否对给定输入的不同上下文文档的生成进行去重。如果在使用分布式后端进行训练时使用，必须将其设置为False。
num_return_sequences(int, optional, 默认为 1) — 每个批次元素的独立计算返回序列的数量。请注意，这不是我们传递给generator的generate()函数的值，其中我们将num_return_sequences设置为num_beams。
num_beams (int, optional, defaults to 1) — Beam search 的 beam 数量。1 表示没有 beam search。
n_docs（int，可选，默认为config.n_docs）- 要检索的文档数量和/或要生成答案的文档数量。
kwargs（Dict[str, Any]，可选）- 额外的 kwargs 将传递给 generate()。

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

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

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

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

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

RagModel

`class transformers.RagModel`

`forward`

RagSequenceForGeneration

`class transformers.RagSequenceForGeneration`

`forward`

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

RagModel

class transformers.RagModel

forward

RagSequenceForGeneration

class transformers.RagSequenceForGeneration

forward

热门文章

最新文章

相关电子书

`class transformers.RagModel`

`forward`

`class transformers.RagSequenceForGeneration`

`forward`