Transformers 4.37 中文文档（五十三）

原文：huggingface.co/docs/transformers

Qwen2

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/qwen2

概述

Qwen2 是 Qwen 团队推出的大型语言模型新系列。之前，我们发布了 Qwen 系列，包括 Qwen-72B、Qwen-1.8B、Qwen-VL、Qwen-Audio 等。

模型详情

Qwen2 是一个包含不同模型大小的解码器语言模型的系列。对于每个大小，我们发布基础语言模型和对齐的聊天模型。它基于 Transformer 架构，具有 SwiGLU 激活、注意力 QKV 偏置、组查询注意力、滑动窗口注意力和全注意力混合等。此外，我们还有一个适应多种自然语言和代码的改进的分词器。

使用提示

Qwen2-7B-beta和Qwen2-7B-Chat-beta可以在Huggingface Hub上找到

接下来，我们演示如何使用Qwen2-7B-Chat-beta进行推断。请注意，我们已经使用 ChatML 格式进行对话，在此演示中，我们展示了如何利用apply_chat_template来实现这一目的。

>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> device = "cuda" # the device to load the model onto

>>> model = AutoModelForCausalLM.from_pretrained("Qwen2/Qwen2-7B-Chat-beta", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen2/Qwen2-7B-Chat-beta")

>>> prompt = "Give me a short introduction to large language model."

>>> messages = [{"role": "user", "content": prompt}]

>>> text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

>>> model_inputs = tokenizer([text], return_tensors="pt").to(device)

>>> generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512, do_sample=True)

>>> generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)]

>>> response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

Qwen2Config

class transformers.Qwen2Config

<来源>

( vocab_size = 151936 hidden_size = 4096 intermediate_size = 22016 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 32 hidden_act = 'silu' max_position_embeddings = 32768 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True tie_word_embeddings = False rope_theta = 10000.0 use_sliding_window = False sliding_window = 4096 max_window_layers = 28 attention_dropout = 0.0 **kwargs )

参数

• vocab_size（int，可选，默认为 151936）— Qwen2 模型的词汇量。定义了在调用 Qwen2Model 时可以表示的不同标记的数量。
• hidden_size（int，可选，默认为 4096）— 隐藏表示的维度。
• intermediate_size（int，可选，默认为 22016）— MLP 表示的维度。
• num_hidden_layers（int，可选，默认为 32）— Transformer 编码器中的隐藏层数量。
• num_attention_heads（int，可选，默认为 32）— Transformer 编码器中每个注意力层的注意力头数。
• num_key_value_heads（int，可选，默认为 32）— 这是应该用于实现 Grouped Query Attention 的 key_value 头的数量。如果num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention（MHA），如果num_key_value_heads=1，模型将使用 Multi Query Attention（MQA），否则将使用 GQA。将多头检查点转换为 GQA 检查点时，应通过均值池化构建每个组键和值头，以包含该组中所有原始头的平均值。有关更多详细信息，请查看此论文。如果未指定，将默认为32。
• hidden_act（str或function，可选，默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。
• max_position_embeddings（int，可选，默认为 32768）— 该模型可能会使用的最大序列长度。
• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• rms_norm_eps（float，可选，默认为 1e-06）— rms 归一化层使用的 epsilon。
• use_cache（bool，可选，默认为True）— 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
• tie_word_embeddings（bool，可选，默认为False）— 模型的输入和输出词嵌入是否应该绑定。
• rope_theta（float，可选，默认为 10000.0）— RoPE 嵌入的基本周期。
• use_sliding_window（bool，可选，默认为False）— 是否使用滑动窗口注意力。
• sliding_window（int，可选，默认为 4096）— 滑动窗口注意力（SWA）窗口大小。如果未指定，将默认为4096。
• max_window_layers (int, 可选, 默认为 28) — 使用 SWA（滑动窗口注意力）的层数。底层使用 SWA，而顶层使用完全注意力。
• attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的丢弃比率。

这是配置类，用于存储 Qwen2Model 的配置。它用于根据指定的参数实例化一个 Qwen2 模型，定义模型架构。使用默认值实例化配置将产生类似于 Qwen2-7B-beta Qwen/Qwen2-7B-beta的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import Qwen2Model, Qwen2Config

>>> # Initializing a Qwen2 style configuration
>>> configuration = Qwen2Config()

>>> # Initializing a model from the Qwen2-7B style configuration
>>> model = Qwen2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Qwen2Tokenizer

class transformers.Qwen2Tokenizer

<来源>

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = None eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' clean_up_tokenization_spaces = False split_special_tokens = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。
• merges_file (str) — 合并文件的路径。
• errors (str, 可选, 默认为"replace") — 解码字节为 UTF-8 时要遵循的范例。查看bytes.decode以获取更多信息。
• unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
• bos_token（str，可选）–序列标记的开头。不适用于此标记器。
• eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
• pad_token（str，optional，默认为"<|endoftext|>"）–用于填充的令牌，例如，在批处理不同长度的序列时。
• clean_up_tokenization_spaces (bool, 可选, 默认为False) — 模型是否应清除在分词过程中拆分输入文本时添加的空格。对于这个分词器不适用，因为分词不会添加空格。
• split_special_token（bool，optional，默认为False）–在标记化过程中是否应拆分特殊标记。默认行为是不拆分特殊标记。这意味着，如果<|endoftext|>是eos_token，则tokenizer.tokenize("<|endoftext|>") = ['<|endoftext|>']。否则，如果split_special_tokens=True，则tokenizer.tokenize("<|endoftext|>")将被赋予[''<'', ''|'', ''endo'', ''ft'', ''ext'', ''|'', ''>'']。这一论点目前只支持“慢速”标记化器。

构建一个 Qwen2 分词器。基于字节级字节对编码。

与 GPT2Tokenizer 相同，这个分词器已经训练过，将空格视为标记的一部分，因此一个单词会

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import Qwen2Tokenizer

>>> tokenizer = Qwen2Tokenizer.from_pretrained("Qwen/Qwen-tokenizer")
>>> tokenizer("Hello world")["input_ids"]
[9707, 1879]

>>> tokenizer(" Hello world")["input_ids"]
[21927, 1879]

这是预期的。

您不应该使用 GPT2Tokenizer，因为其具有不同的 pretokenization 规则。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

Qwen2TokenizerFast

class transformers.Qwen2TokenizerFast

<来源>

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = None eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

参数

• vocab_file (str, 可选) — 词汇文件的路径。
• merges_file (str, 可选) — 合并文件的路径。
• tokenizer_file (str, 可选) — 包含加载分词器所需的所有内容的tokenizers文件的路径（通常具有.json 扩展名）。
• unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。不适用于此标记器。
• bos_token（str，可选）–序列标记的开头。不适用于此标记器。
• eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
• pad_token（str，optional，默认为"<|endoftext|>"）–用于填充的令牌，例如，在批处理不同长度的序列时。

构建一个“快速”Qwen2 分词器（由 HuggingFace 的tokenizers库支持）。基于字节级字节对编码。

与 GPT2Tokenizer 相同，这个分词器已经训练过，将空格视为标记的一部分，因此一个单词会

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import Qwen2TokenizerFast

>>> tokenizer = Qwen2TokenizerFast.from_pretrained("Qwen/Qwen-tokenizer")
>>> tokenizer("Hello world")["input_ids"]
[9707, 1879]

>>> tokenizer(" Hello world")["input_ids"]
[21927, 1879]

这是预期的。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

Qwen2Model

class transformers.Qwen2Model

<来源>

( config: Qwen2Config )

参数

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

裸 Qwen2 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个Qwen2DecoderLayer。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）—词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）—用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值：
  • 1 表示未被“掩盖”的标记，
  • 0 表示被“掩盖”的标记。

  什么是注意力掩码？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用past_key_values，可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 如果您想要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被“掩盖”，
  • 0 表示头部被“掩盖”。
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 什么是位置 ID？
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）—预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。 允许两种格式：
  • 一个 Cache 实例；
  • 长度为config.n_layers的元组的元组（torch.FloatTensor），每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统缓存格式。 如果使用past_key_values，用户可以选择仅输入最后的input_ids（即不将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

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

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

Qwen2ForCausalLM

class transformers.Qwen2ForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 输入序列标记在词汇表中的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。

  什么是注意力掩码？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用past_key_values，可选择仅输入最后的decoder_input_ids（参见past_key_values）。 如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 什么是位置 ID？
• past_key_values (Cache或tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。 允许两种格式：
  • 一个 Cache 实例；
  • 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，将返回传统缓存格式。 如果使用了past_key_values，用户可以选择仅输入最后的input_ids（那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。 参数 — labels (torch.LongTensor of shape (batch_size, sequence_length), optional): 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含各种元素，取决于配置（Qwen2Config）和输入。

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失（用于下一个标记预测）。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出+每个层的输出）。 模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, Qwen2ForCausalLM

>>> model = Qwen2ForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
>>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

Qwen2ForSequenceClassification

class transformers.Qwen2ForSequenceClassification

<来源>

( config )

参数

• config（Qwen2Config）- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

Qwen2 模型变压器，顶部带有序列分类头（线性层）。

Qwen2ForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则会找到每行中不是填充标记的最后一个标记。如果未定义pad_token_id，则会简单地取每行批次中的最后一个值。由于在传递inputs_embeds而不是input_ids时无法猜测填充标记，因此会执行相同操作（取每行批次中的最后一个值）。

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

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）- 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）- 避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]中：
  • 1 表示标记是未掩码，
  • 0 表示掩码的标记。

  什么是注意力掩码？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（请参见past_key_values）。 如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部是未掩码，
  • 0 表示头部是掩码。
• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）- 输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 什么是位置 ID？
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。 允许两种格式：
  • 一个 Cache 实例；
  • 元组tuple(torch.FloatTensor)的长度为config.n_layers，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统的缓存格式。

  模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。 如果使用了past_key_values，用户可以选择仅输入最后的input_ids（即那些没有将它们的过去键值状态提供给该模型的输入）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。

• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型内部的嵌入查找矩阵，这将非常有用。
• use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

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

RAG

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/rag

概述

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

基于论文Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks by 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 **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) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• 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 ) → export const metadata = 'undefined';EncoderDecoderConfig

返回

EncoderDecoderConfig

配置对象的一个实例

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

RagTokenizer

class transformers.RagTokenizer

<来源>

( question_encoder generator )

Rag 特定输出

class transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput

<来源>

( loss: Optional = None 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 )

参数

• loss (torch.FloatTensor of shape (1,), optional, 当提供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], optional, 当传递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 of shape (batch_size, config.n_docs, hidden_size), optional, 当output_retrieved=True时返回） — 检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起用于计算doc_scores。
• retrieved_doc_ids (torch.LongTensor of shape (batch_size, config.n_docs), optional, 当output_retrieved=True时返回） — 检索器检索到的嵌入文档的索引。
• 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后处理得到的注意力掩码。
• question_encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型问题编码器汇总输出的最后一层的隐藏状态序列。
• question_enc_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 问题编码器每一层的输出隐藏状态以及初始嵌入输出。
• question_enc_attentions (tuple(torch.FloatTensor), optional, 当传递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 of shape (batch_size, sequence_length, hidden_size), optional) — 模型生成器编码器最后一层的隐藏状态序列。
• generator_enc_hidden_states (tuple(torch.FloatTensor), optional, 当传递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 之后，用于计算交叉注意力头中的加权平均值。

用于检索器增强边际化模型输出的基类。

class transformers.models.rag.modeling_rag.RetrievAugLMOutput

<来源>

( 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，形状为(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，形状为(batch_size, sequence_length, hidden_size)，optional) — 问题编码器最后一层的隐藏状态序列模型的汇聚输出。
• question_enc_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，一个用于每层的输出）。 问题编码器在每一层输出的隐藏状态加上初始嵌入输出。
• question_enc_attentions (tuple(torch.FloatTensor), optional, 当传递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)，optional) — 模型生成器编码器最后一层的隐藏状态序列。
• generator_enc_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，一个用于每层的输出）。 生成器编码器在每一层输出的隐藏状态加上初始嵌入输出。
• generator_enc_attentions (tuple(torch.FloatTensor), optional, 当传递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), optional, 当传递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 之后，用于计算交叉注意力头中的加权平均值。

RagRetriever

class transformers.RagRetriever

< source >

( config question_encoder_tokenizer generator_tokenizer index = None init_retrieval = True )

参数

• config（RagConfig）— 用于 RAG 模型的 Retriever 的配置。包含指示要构建哪个Index的参数。您可以使用config.index_name="custom"加载自己的自定义数据集，或者使用数据集库中的一个规范的数据集（默认）例如config.index_name="wiki_dpr"。
• question_encoder_tokenizer（PreTrainedTokenizer）— 用于标记化问题的分词器。它用于解码问题，然后使用生成器的分词器。
• generator_tokenizer（PreTrainedTokenizer）— 用于 RagModel 生成器部分的分词器。
• index（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 >

( )

检索器初始化函数。将索引加载到内存中。

postprocess_docs

< source >

( docs input_strings prefix n_docs return_tensors = None ) → export const metadata = 'undefined';tuple(tensors)

参数

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

返回

tuple(tensors)

一个包含两个元素的元组：上下文化的input_ids和一个兼容的attention_mask。

后处理检索到的docs并将它们与input_strings组合。

retrieve

< source >

( question_hidden_states: ndarray n_docs: int ) → export const metadata = 'undefined';Tuple[np.ndarray, np.ndarray, List[dict]]

参数

• question_hidden_states（形状为(batch_size, vector_size)的np.ndarray）— 一批要检索的查询向量。
• n_docs（int）— 每个查询检索的文档数。

返回

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

一个包含以下对象的元组：

• retrieved_doc_embeds（形状为(batch_size, n_docs, dim)的np.ndarray）— 检索到的文档的检索嵌入，每个查询一个。
• doc_ids（形状为(batch_size, n_docs)的np.ndarray）— 索引中文档的 id
• doc_dicts（List[dict]）：每个查询的retrieved_doc_embeds示例。

为指定的question_hidden_states检索文档。

PytorchHide Pytorch content

RagModel

class transformers.RagModel

< source >

( 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__特殊方法。

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

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()文档，了解如何设置其他生成输入参数的更多信息。

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)

TFRagSequenceForGeneration

class 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 架构中生成器的序列到序列模型。
• retriever (RagRetriever) — 一个检索器类，封装了一个 faiss 索引，用于获取当前输入的上下文文档。

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

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

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

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

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

该模型可以使用 RagRetriever 进行端到端生成，也可以与检索器的输出组合在多个步骤中使用—查看更多详细信息的示例。该模型兼容任何自动编码模型作为question_encoder，兼容任何带有语言模型头的序列到序列模型作为generator。已经测试过使用 TFDPRQuestionEncoder 作为question_encoder和 TFBartForConditionalGeneration 作为generator。

这个模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

该模型目前处于开发状态，现在仅完全支持即时模式，并且可能无法以 SavedModel 格式导出。

call

<来源>

( 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 ) → export const metadata = 'undefined';transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput or tuple(tf.Tensor)

参数

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

  什么是注意力掩码?

• encoder_outputs (tuple(tuple(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 (tf.Tensor的形状为(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(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。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后处理得到的输入 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时返回): 从检索到的文档和问题编码器input_ids后处理得到的注意力掩码。 如果模型未使用retriever初始化，则必须在前向传递中提供context_attention_mask。context_attention_mask由__call__()返回。
• use_cache (bool, optional, 默认为True) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。
• output_retrieved(bool, optional) — 是否返回retrieved_doc_embeds、retrieved_doc_ids、context_input_ids和context_attention_mask。有关更多详细信息，请参见返回的张量。
• return_dict (bool, optional) — 是否返回TFRetrievAugLMOutput而不是普通元组。
• n_docs (int, optional, 默认为`config.n_docs“) — 要检索的文档数量和/或要生成答案的文档数量。
• exclude_bos_score (bool, optional) — 仅在传递labels时相关。如果为True，则在计算损失时忽略 BOS 标记的分数。
• labels (tf.Tensor or np.ndarray of shape (batch_size, sequence_length), optional) — 根据 Rag-Sequence 模型公式计算交叉熵分类损失的标签。有关 Rag-Sequence 公式的详细信息，请参见arxiv.org/pdf/2005.11401.pdf第 2.1 节。索引应在[0, ..., config.vocab_size - 1]范围内。
• reduce_loss (bool, optional) — 仅在传递labels时相关。如果为True，则使用tf.Tensor.sum操作减少 NLL 损失。
• kwargs (Dict[str, any], optional, 默认为*{}) — 遗留字典，模型可以使用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 (tf.Tensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失。
• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数。该分数可能针对每个词汇标记在所有文档上进行边缘化。
• past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含预先计算的隐藏状态（解码器中的键和值在注意力块中）的tf.Tensor，可用于加速顺序解码（请参见past_key_values输入）。
• doc_scores (tf.Tensor of shape (batch_size, config.n_docs)) — 检索到的文档嵌入（参见retrieved_doc_embeds）与question_encoder_last_hidden_state之间的分数。
• retrieved_doc_embeds (tf.Tensor of shape (batch_size, config.n_docs, hidden_size), optional, returned when output_retrieved=True) — 检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起用于计算doc_scores。
• retrieved_doc_ids (tf.Tensor (int32) of shape (batch_size, config.n_docs), optional, returned when output_retrieved=True) — 由检索器检索的嵌入文档的索引。
• context_input_ids（tf.Tensor（int32）形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回）— 从检索到的文档和问题编码器 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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 问题编码器最后一层的隐藏状态序列模型的池化输出。
• 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元组（每层一个）。 问题编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• generator_enc_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 模型生成器编码器最后一层的隐藏状态序列。
• 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元组（每层一个）。 生成器编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• 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元组（每层一个）。 生成器解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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 ) → export const metadata = 'undefined';tf.Tensor of shape (batch_size * num_return_sequences, sequence_length)

参数

• input_ids (tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用作生成提示的序列。如果未传递input_ids，则必须提供context_input_ids。
• attention_mask (tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内：- 1 表示未屏蔽的标记，- 0 表示已屏蔽的标记。什么是注意力掩码？
• context_input_ids (tf.Tensor，形状为(batch_size * config.n_docs, config.max_combined_length)，可选，当output_retrieved=True时返回) — 从检索文档和问题编码器 input_ids 后处理得到的输入 ID。
• 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()函数的值，其中我们将num_return_sequences设置为num_beams。
• num_beams (int, 可选, 默认为 1) — Beam 搜索的数量。1 表示没有 beam 搜索。
• n_docs (int，可选，默认为config.n_docs) — 要检索的文档数量和/或要为其生成答案的文档数量。
• kwargs (Dict[str, Any]，可选) — 额外的 kwargs 将传递给 generate()

返回

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

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

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

TFRagTokenForGeneration

class transformers.TFRagTokenForGeneration

<来源>

( 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 的前向方法覆盖了__call__特殊方法。

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

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

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

<来源>

( 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: 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 do_marginalize: bool | None = None labels: np.ndarray | tf.Tensor | None = None reduce_loss: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput or tuple(tf.Tensor)

参数

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

  什么是注意力掩码？

• encoder_outputs (tuple(tuple(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 (tf.Tensor，形状为(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(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。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后处理的输入 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, optional, 默认为`config.n_docs“) — 要检索的文档数量和/或要生成答案的文档数量。
• do_marginalize (bool，可选) — 如果为True，通过使用torch.nn.functional.log_softmax将对数归一化到所有文档上。
• labels (tf.Tensor or np.ndarray of shape (batch_size, sequence_length), optional) — 根据 Rag-Token 模型公式计算交叉熵分类损失的标签。有关 Rag-Token 公式的详细信息，请参阅arxiv.org/pdf/2005.11401.pdf第 2.1 节。索引应在[0, ..., config.vocab_size - 1]范围内。
• reduce_loss (bool, optional) — 仅在传递labels时相关。如果为True，则使用tf.Tensor.sum操作减少 NLL 损失。
• kwargs (Dict[str, any], optional, 默认为*{}) — 旧字典，模型可以使用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 (tf.Tensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失。
• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数。该分数可能针对每个词汇标记在所有文档上进行边缘化。
• past_key_values (List[tf.Tensor], optional, 当传递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 of shape (batch_size, config.n_docs)) — 每个检索到的文档嵌入（参见retrieved_doc_embeds）与question_encoder_last_hidden_state之间的得分。
• retrieved_doc_embeds (tf.Tensor of shape (batch_size, config.n_docs, hidden_size), optional, 当output_retrieved=True时返回) — 检索器检索到的嵌入文档。与question_encoder_last_hidden_state一起用于计算doc_scores。
• retrieved_doc_ids (tf.Tensor (int32) of shape (batch_size, config.n_docs), optional, 当output_retrieved=True时返回) — 检索器检索到的嵌入文档的索引。
• context_input_ids (tf.Tensor(int32) of shape (batch_size * config.n_docs, config.max_combined_length), optional, 当output_retrieved=True时返回) — 从检索到的文档和问题编码器输入 ids 后处理得到的输入 ids。
• context_attention_mask (tf.Tensor (int32) of shape (batch_size * config.n_docs, config.max_combined_length), optional, 当output_retrieved=True时返回) — 从检索到的文档和问题编码器input_ids后处理得到的注意力掩码。
• question_encoder_last_hidden_state (tf.Tensor of shape (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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 模型生成器编码器最后一层的隐藏状态序列。
• 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元组（每层一个）。 生成器编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• 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元组（每层一个）。 生成器解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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 ) → export const metadata = 'undefined';tf.Tensor of shape (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]中：
  • 对于未被masked的标记，值为 1，
  • 对于被masked的标记，值为 0。

  什么是注意力掩码？

• 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_input_ids。context_input_ids由__call__()返回。
• doc_scores（形状为(batch_size, config.n_docs)的tf.Tensor）- 每个检索文档嵌入（参见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，可选）- 用作生成调用的基本参数化的生成配置。传递给生成匹配generation_config属性的**kwargs将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1）从generation_config.json模型文件中，如果存在；2）从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。
• logits_processor（TFLogitsProcessorList，可选）- 自定义 logits 处理器，补充从参数和模型配置构建的默认 logits 处理器。如果传递的 logit 处理器已经使用参数或模型配置创建，则会抛出错误。
• kwargs（Dict[str, Any]，可选）- generate_config的特定于模型的参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。

返回

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

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

实现 TFRAG 令牌解码。 context_input_ids = None context_attention_mask = None doc_scores = None n_docs = None generation_config = None logits_processor = [] **kwargs ) → export const metadata = ‘undefined’;tf.Tensor of shape (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]`中：

    +   对于未被`masked`的标记，值为 1，

    +   对于被`masked`的标记，值为 0。

    什么是注意力掩码？

+   `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_input_ids`。`context_input_ids`由`__call__()`返回。

+   `doc_scores`（形状为`(batch_size, config.n_docs)`的`tf.Tensor`）- 每个检索文档嵌入（参见`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`，*可选*）- 用作生成调用的基本参数化的生成配置。传递给生成匹配`generation_config`属性的`**kwargs`将覆盖它们。如果未提供`generation_config`，将使用默认值，其加载优先级如下：1）从`generation_config.json`模型文件中，如果存在；2）从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。

+   `logits_processor`（`TFLogitsProcessorList`，*可选*）- 自定义 logits 处理器，补充从参数和模型配置构建的默认 logits 处理器。如果传递的 logit 处理器已经使用参数或模型配置创建，则会抛出错误。

+   `kwargs`（`Dict[str, Any]`，*可选*）- `generate_config`的特定于模型的参数化和/或将转发到模型的`forward`函数的其他模型特定 kwargs。

返回

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

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

实现 TFRAG 令牌解码。