Hugging Face 的 LOGO

Transformers 文件

RAG

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

RAG

PyTorch TensorFlow FlashAttention

概述

檢索增強生成 (“RAG”) 模型結合了預訓練的密集檢索 (DPR) 模型和序列到序列模型的強大功能。RAG 模型檢索文件，將其傳遞給序列到序列模型，然後進行邊緣化以生成輸出。檢索器和序列到序列模組均從預訓練模型初始化，並進行聯合微調，從而使檢索和生成都能適應下游任務。

它基於 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 合著的論文 《用於知識密集型 NLP 任務的檢索增強生成》。

論文摘要如下：

大型預訓練語言模型已被證明可以在其引數中儲存事實知識，並在下游 NLP 任務上進行微調時取得最先進的結果。然而，它們訪問和精確操縱知識的能力仍然有限，因此在知識密集型任務上，它們的效能落後於特定任務的架構。此外，為其決策提供來源並更新其世界知識仍然是開放的研究問題。具有對顯式非引數記憶體的可微分訪問機制的預訓練模型可以克服此問題，但迄今為止僅針對提取式下游任務進行了研究。我們探索了一種用於檢索增強生成 (RAG) 的通用微調方法——這些模型將預訓練的引數記憶和非引數記憶相結合以進行語言生成。我們引入了 RAG 模型，其中引數記憶是預訓練的 seq2seq 模型，非引數記憶是維基百科的密集向量索引，透過預訓練的神經檢索器訪問。我們比較了兩種 RAG 公式，一種在整個生成序列中使用相同的檢索到的段落進行條件，另一種可以為每個 token 使用不同的段落。我們對我們的模型進行微調，並在各種知識密集型 NLP 任務上進行評估，並在三個開放域問答任務上取得了最先進的成果，超越了引數 seq2seq 模型和特定任務的檢索提取架構。對於語言生成任務，我們發現 RAG 模型比最先進的僅引數 seq2seq 基線生成更具體、多樣化和事實性更強的語言。

該模型由 ola13 貢獻。

使用技巧

檢索增強生成 (“RAG”) 模型結合了預訓練的密集檢索 (DPR) 和 Seq2Seq 模型的強大功能。RAG 模型檢索文件，將其傳遞給 seq2seq 模型，然後進行邊緣化以生成輸出。檢索器和 seq2seq 模組均從預訓練模型初始化，並進行聯合微調，從而使檢索和生成都能適應下游任務。

RagConfig

class transformers.RagConfig

< >

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

引數

  • title_sep (str, 可選, 預設為 " / ") — 當呼叫 RagRetriever 時，在檢索到的文件標題和文字之間插入的分隔符。
  • doc_sep (str, 可選, 預設為 " // ") — 當呼叫 RagRetriever 時，在檢索到的文件文字和原始輸入之間插入的分隔符。
  • n_docs (int, 可選, 預設為 5) — 要檢索的文件數量。
  • max_combined_length (int, 可選, 預設為 300) — 由 __call__() 返回的上下文輸入的***大***長度。
  • retrieval_vector_size (int, 可選, 預設為 768) — RagRetriever 索引的文件嵌入維度。
  • retrieval_batch_size (int, 可選, 預設為 8) — 檢索批處理大小，定義為同時向 RagRetriever 中封裝的 faiss 索引發出的查詢數量。
  • dataset (str, 可選, 預設為 "wiki_dpr") — HuggingFace 資料集中索引資料集的識別符號（使用 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 token。
  • 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 時強制作為最後一個生成的 token 的 ID。通常設定為 eos_token_id。

RagConfig 儲存 Rag模型 的配置。配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 文件。

from_question_encoder_generator_configs

< >

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

返回

EncoderDecoderConfig

一個配置物件的例項

從預訓練編碼器模型配置和解碼器模型配置例項化一個 EncoderDecoderConfig（或派生類）。

RagTokenizer

class transformers.RagTokenizer

< >

( question_encoder generator )

Rag 特定輸出

class transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None retrieved_doc_embeds: typing.Optional[torch.FloatTensor] = None retrieved_doc_ids: typing.Optional[torch.LongTensor] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None question_encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None question_enc_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None question_enc_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_enc_last_hidden_state: typing.Optional[torch.FloatTensor] = None generator_enc_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_enc_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_dec_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_dec_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數。分數可能在所有文件中針對每個詞彙標記進行邊緣化。
  • doc_scores (torch.FloatTensor，形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）與 question_encoder_last_hidden_state 之間的分數。
  • past_key_values (list[torch.FloatTensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 torch.FloatTensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解碼器預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • retrieved_doc_embeds (torch.FloatTensor，形狀為 (batch_size, config.n_docs, hidden_size)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件。與 question_encoder_last_hidden_state 一起用於計算 doc_scores。
  • retrieved_doc_ids (torch.LongTensor，形狀為 (batch_size, config.n_docs)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件的索引。
  • context_input_ids (torch.LongTensor，形狀為 (batch_size * config.n_docs, config.max_combined_length)，可選，當 output_retrieved=True 時返回) — 由檢索器從檢索到的文件和問題編碼器 input_ids 中後處理得到的輸入 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • question_enc_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • generator_enc_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • generator_dec_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • generator_dec_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • generator_cross_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的交叉注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

檢索增強邊緣化模型輸出的基類。

class transformers.models.rag.modeling_rag.RetrievAugLMOutput

< >

( logits: typing.Optional[torch.FloatTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None retrieved_doc_embeds: typing.Optional[torch.FloatTensor] = None retrieved_doc_ids: typing.Optional[torch.LongTensor] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None question_encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None question_enc_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None question_enc_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_enc_last_hidden_state: typing.Optional[torch.FloatTensor] = None generator_enc_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_enc_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_dec_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_dec_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None generator_cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = 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)，可選) — 模型問題編碼器池化輸出的最後一層輸出的隱藏狀態序列。
  • question_enc_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • question_enc_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • generator_enc_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • generator_dec_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每一層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每一層輸出和初始嵌入輸出時的隱藏狀態。

  • generator_dec_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • generator_cross_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的交叉注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

RagRetriever

class transformers.RagRetriever

< >

( config question_encoder_tokenizer generator_tokenizer index = None init_retrieval = True )

引數

  • config (RagConfig) — 此檢索器所使用的 RAG 模型的配置。包含指示要構建哪個 Index 的引數。您可以載入自己的自定義資料集，例如使用 config.index_name="custom"，或使用 datasets 庫中的規範資料集（預設），例如使用 config.index_name="wiki_dpr"。
  • question_encoder_tokenizer (PreTrainedTokenizer) — 用於對問題進行分詞的分詞器。它用於解碼問題，然後使用 generator_tokenizer。
  • 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 supported index (e.g., Faiss or other index types depending on your setup)
>>> 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"  # 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

< >

( )

檢索器初始化函式。它將索引載入到記憶體中。

postprocess_docs

< >

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

引數

  • docs (dict) — 檢索到的文件。
  • input_strings (str) — 透過 preprocess_query 解碼的輸入字串。
  • prefix (str) — 新增到每個輸入開頭的、通常與基於 T5 的模型一起使用的字首。

返回

tuple(tensors)

一個元組，由兩個元素組成：上下文的 input_ids 和相容的 attention_mask。

後處理檢索到的 docs 並將其與 input_strings 結合。

檢索

< >

( question_hidden_states: ndarray n_docs: int ) → tuple[np.ndarray, np.ndarray, list[dict]]

引數

  • question_hidden_states (np.ndarray of shape (batch_size, vector_size)) — 用於檢索的查詢向量批次。
  • 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 檢索文件。

Pytorch
隱藏 Pytorch 內容

RagModel

class transformers.RagModel

< >

( config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None question_encoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None generator: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None retriever: typing.Optional[transformers.models.rag.retrieval_rag.RagRetriever] = None **kwargs )

引數

  • config (PretrainedConfig, optional) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
  • question_encoder (PreTrainedModel, optional) — 負責將問題編碼為用於檢索的隱藏狀態的模型。
  • generator (PreTrainedModel, optional) — 負責根據檢索到的文件生成文字的模型。
  • retriever (RagRetriever, optional) — 負責根據編碼問題從知識庫中檢索文件的元件。

裸露的 Rag 模型輸出原始隱藏狀態，頂部沒有任何特定頭部。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件以瞭解所有與一般用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None doc_scores: typing.Optional[torch.FloatTensor] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_retrieved: typing.Optional[bool] = None n_docs: typing.Optional[int] = None ) → 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] 之間：

    • 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_input_ids (形狀為 (batch_size, target_sequence_length) 的 torch.LongTensor, 可選) — 詞彙表中解碼器輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是解碼器輸入 ID？

  • decoder_attention_mask (形狀為 (batch_size, target_sequence_length) 的 torch.BoolTensor, 可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也將使用因果掩碼。
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • Cache 例項，請參閱我們的 kv cache 指南；
    • 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量）。這也被稱為舊版快取格式。

    模型將輸出與作為輸入提供的快取格式相同的快取格式。如果未傳遞 past_key_values，則將返回舊版快取格式。

    如果使用 past_key_values，使用者可以選擇只輸入形狀為 (batch_size, 1) 的最後 input_ids（那些沒有將其過去的鍵值狀態提供給此模型的）而不是形狀為 (batch_size, sequence_length) 的所有 input_ids。

  • 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 (形狀為 (batch_size * config.n_docs, config.max_combined_length) 的 torch.LongTensor, 可選, 當 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，則返回 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, 可選) — 要檢索的文件數量。

返回

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 (形狀為 (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 時返回) — 由檢索器從檢索到的文件和問題編碼器 input_ids 後處理得到的輸入 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_cross_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的交叉注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭部中的加權平均。

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: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None question_encoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None generator: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None retriever: typing.Optional[transformers.models.rag.retrieval_rag.RagRetriever] = None **kwargs )

引數

  • config (PretrainedConfig, 可選) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
  • question_encoder (PreTrainedModel, 可選) — 負責將問題編碼為用於檢索的隱藏狀態的模型。
  • generator (PreTrainedModel, 可選) — 負責根據檢索到的文件生成文字的模型。
  • retriever (RagRetriever, 可選) — 負責根據編碼問題從知識庫中檢索文件的元件。

RAG-序列模型實現。它在前向傳遞中執行 RAG-序列特定邊緣化。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件以瞭解所有與一般用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_retrieved: typing.Optional[bool] = None exclude_bos_score: typing.Optional[bool] = None reduce_loss: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None n_docs: typing.Optional[int] = None **kwargs ) → transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (形狀為 (batch_size, sequence_length) 的 torch.LongTensor) — 詞彙表中輸入序列標記的索引。RagConfig 用於初始化模型，它還指定要使用的相容生成器分詞器。使用該分詞器類來獲取索引。

    什麼是輸入 ID？

  • attention_mask (形狀為 (batch_size, sequence_length) 的 torch.Tensor, 可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值選擇在 [0, 1] 之間：

    • 1 表示未被遮蔽的標記，
    • 0 表示被遮蔽的標記。

    什麼是注意力掩碼？

  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可選) — 元組由 (generator_enc_last_hidden_state, 可選: generator_enc_hidden_states, 可選: generator_enc_attentions) 組成。形狀為 (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_input_ids (形狀為 (batch_size, target_sequence_length) 的 torch.LongTensor, 可選) — 詞彙表中解碼器輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是解碼器輸入 ID？

  • decoder_attention_mask (torch.BoolTensor, 形狀為 (batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也將使用因果掩碼。
  • past_key_values (tuple[tuple[torch.Tensor]], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 Cache 例項，請參閱我們的 kv 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。

  • 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__() 返回。
  • 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 計算，更多資訊請參見示例。
  • use_cache (bool, 可選) — 如果設定為 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。更多詳細資訊請參見返回張量。
  • exclude_bos_score (bool, 可選) — 僅當傳遞 labels 時相關。如果為 True，則在計算損失時忽略 BOS 標記的分數。
  • reduce_loss (bool, 可選) — 僅當傳遞 labels 時相關。如果為 True，則使用 torch.Tensor.sum 操作來減少 NLL 損失。
  • labels (torch.LongTensor, 形狀為 (batch_size, sequence_length), 可選) — 用於計算掩碼語言建模損失的標籤。索引應為 [0, ..., config.vocab_size] 或 -100（參見 input_ids 文件字串）。索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 中的標記計算。
  • n_docs (int, 可選) — 要檢索的文件數量。

返回

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

一個 transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含取決於配置 (RagConfig) 和輸入的不同元素。

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。

  • logits (形狀為 (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 時返回) — 由檢索器從檢索到的文件和問題編碼器 input_ids 後處理得到的輸入 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_cross_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的交叉注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭部中的加權平均。

RagSequenceForGeneration 的 forward 方法，覆蓋了 __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,
... )

生成

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None do_deduplication: typing.Optional[bool] = None num_return_sequences: typing.Optional[int] = None num_beams: typing.Optional[int] = None n_docs: typing.Optional[int] = None **model_kwargs ) → torch.LongTensor 形狀為 (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。
  • context_attention_mask (torch.LongTensor, 形狀為 (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 (torch.FloatTensor, 形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）和 question_encoder_last_hidden_state 之間的分數。

    如果模型未用 retriever 初始化，或者未提供 input_ids，則必須向正向傳遞提供 doc_scores。doc_scores 由 __call__() 返回。

  • do_deduplication (bool, 可選) — 是否對給定輸入的來自不同上下文文件的生成進行去重。在分散式後端訓練時，必須將其設定為 False。
  • num_return_sequences(int, 可選, 預設為 1) — 批處理中每個元素獨立計算的返回序列的數量。請注意，這與我們傳遞給 generator 的 [generate()](/docs/transformers/v4.53.3/en/main_classes/text_generation#transformers.GenerationMixin.generate) 函式的值不同，在該函式中我們將 num_return_sequences 設定為 num_beams。
  • num_beams (int, 可選, 預設為 1) — 束搜尋的束數量。1 表示沒有束搜尋。
  • n_docs (int, 可選, 預設為 config.n_docs) — 要檢索的文件數量和/或要生成答案的文件數量。
  • kwargs (dict[str, Any], 可選) — 額外的 kwargs 將傳遞給 generate()。

返回

torch.LongTensor，形狀為 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二個維度（序列長度）等於 max_length，或者如果所有批次由於 eos_token_id 而提前結束，則更短。

實現了 RAG 序列的“徹底”解碼。有關如何設定其他生成輸入引數的更多資訊，請閱讀 generate() 文件。

RagTokenForGeneration

class transformers.RagTokenForGeneration

< >

( config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None question_encoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None generator: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None retriever: typing.Optional[transformers.models.rag.retrieval_rag.RagRetriever] = None **kwargs )

引數

  • config (PretrainedConfig, 可選) — 模型配置類，包含模型的所有引數。使用配置檔案初始化模型不會載入與模型相關的權重，僅載入配置。請檢視 from_pretrained() 方法以載入模型權重。
  • question_encoder (PreTrainedModel, 可選) — 負責將問題編碼為隱藏狀態以進行檢索的模型。
  • generator (PreTrainedModel, 可選) — 負責根據檢索到的文件生成文字的模型。
  • retriever (RagRetriever, 可選) — 負責根據編碼問題從知識庫中檢索文件的元件。

RAG-token 模型實現。它在正向傳遞中執行 RAG-token 特定的邊緣化。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件以瞭解所有與一般用法和行為相關的事項。

前向

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_retrieved: typing.Optional[bool] = None do_marginalize: typing.Optional[bool] = None reduce_loss: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None n_docs: typing.Optional[int] = None **kwargs ) → transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或 tuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor, 形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。RagConfig，用於初始化模型，指定要使用的生成器，它還指定了一個相容的生成器分詞器。使用該分詞器類獲取索引。

    什麼是輸入 ID？

  • attention_mask (torch.FloatTensor, 形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值選擇在 [0, 1] 中：

    • 1 表示**未被掩碼**的標記，
    • 0 表示**被掩碼**的標記。

    什麼是注意力掩碼？

  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可選) — 元組包含 (generator_enc_last_hidden_state, 可選: generator_enc_hidden_states, 可選: generator_enc_attentions)。形狀為 (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_input_ids (torch.LongTensor, 形狀為 (batch_size, target_sequence_length), 可選) — 解碼器輸入序列標記在詞彙表中的索引。

    索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參見 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什麼是解碼器輸入 ID？

  • decoder_attention_mask (torch.BoolTensor, 形狀為 (batch_size, target_sequence_length), 可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也將使用因果掩碼。
  • past_key_values (tuple[tuple[torch.Tensor]], 可選) — 預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

    允許兩種格式：

    • 一個 Cache 例項，請參閱我們的 kv 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。

  • 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__() 返回。
  • 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 計算，更多資訊請參見示例。
  • use_cache (bool, 可選) — 如果設定為 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。更多詳細資訊請參見返回張量。
  • do_marginalize (bool, 可選) — 如果為 True，則透過使用 torch.nn.functional.log_softmax 對所有文件的 logits 進行邊緣化。
  • reduce_loss (bool, 可選) — 僅當傳遞 labels 時相關。如果為 True，則使用 torch.Tensor.sum 操作來減少 NLL 損失。
  • labels (torch.LongTensor, 形狀為 (batch_size, sequence_length), 可選) — 用於計算掩碼語言建模損失的標籤。索引應為 [0, ..., config.vocab_size] 或 -100（參見 input_ids 文件字串）。索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 中的標記計算。
  • n_docs (int, 可選) — 要檢索的文件數量。

返回

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

一個 transformers.models.rag.modeling_rag.RetrievAugLMMarginOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含取決於配置 (RagConfig) 和輸入的不同元素。

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。

  • logits (形狀為 (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 時返回) — 由檢索器從檢索到的文件和問題編碼器 input_ids 後處理得到的輸入 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 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 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_cross_attentions (tuple(torch.FloatTensor), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的交叉注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭部中的加權平均。

RagTokenForGeneration 的 forward 方法，覆蓋了 __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)

生成

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None context_input_ids: typing.Optional[torch.LongTensor] = None context_attention_mask: typing.Optional[torch.LongTensor] = None doc_scores: typing.Optional[torch.FloatTensor] = None n_docs: typing.Optional[int] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None prefix_allowed_tokens_fn: typing.Optional[typing.Callable[[int, torch.Tensor], list[int]]] = None logits_processor: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = [] stopping_criteria: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = [] **kwargs ) → torch.LongTensor of shape (batch_size * num_return_sequences, sequence_length)

引數

  • input_ids (torch.LongTensor，形狀為 (batch_size, sequence_length)，可選) — 用於生成提示的序列。如果未傳入 input_ids，則必須提供 context_input_ids。
  • attention_mask (torch.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • context_input_ids (torch.LongTensor，形狀為 (batch_size * config.n_docs, config.max_combined_length)，可選，當 output_retrieved=True 時返回) — 檢索器對檢索到的文件和問題編碼器 input_ids 進行後處理後的輸入 ID。

    如果模型未用 retriever 初始化，則必須向正向傳遞提供 context_input_ids。context_input_ids 由 __call__() 返回。

  • context_attention_mask (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，可選) — 用作生成呼叫的基本引數化的生成配置。傳遞給生成函式的 **kwargs 如果與 generation_config 的屬性匹配，將覆蓋它們。如果未提供 generation_config，將使用預設值，其載入優先順序如下：1) 如果存在 generation_config.json 模型檔案，則從中載入；2) 從模型配置中載入。請注意，未指定的引數將繼承 GenerationConfig 的預設值，應查閱其文件以引數化生成。
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]]，可選) — 如果提供，此函式將在每一步將束搜尋限制為僅允許的標記。如果未提供，則不應用任何限制。此函式接受 2 個引數 inputs_ids 和批次 ID batch_id。它必須返回一個列表，其中包含根據先前生成的標記 inputs_ids 和批次 ID batch_id，下一步生成允許的標記。此引數對於基於字首的受限生成很有用，如 Autoregressive Entity Retrieval 中所述。
  • logits_processor (LogitsProcessorList，可選) — 補充從引數和模型配置構建的預設 logits 處理器。如果傳入的 logits 處理器已使用引數或模型配置建立，則會丟擲錯誤。
  • stopping_criteria (StoppingCriteriaList，可選) — 補充從引數和模型配置構建的預設停止條件。如果傳入的停止條件已使用引數或模型配置建立，則會丟擲錯誤。
  • kwargs (dict[str, Any]，可選) — generate_config 的臨時引數化和/或將轉發到模型 forward 函式的附加模型特定 kwargs。

返回

torch.LongTensor，形狀為 (batch_size * num_return_sequences, sequence_length)

生成的序列。第二維度（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 keras.Model 的子類。請將其作為常規的 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

該模型處於開發階段，因為它目前僅在 eager-mode 中完全支援，並且可能無法以 SavedModel 格式匯出。

呼叫

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None 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 ) → transformers.models.rag.modeling_tf_rag.TFRetrievAugLMOutput 或 tuple(tf.Tensor)

引數

  • input_ids (tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。RagConfig 用於初始化模型，它指定要使用的生成器，也指定相容的生成器分詞器。使用該分詞器類獲取索引。
  • attention_mask (tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • encoder_outputs (tuple(tuple(tf.Tensor)，可選) — 元組包含 (generator_enc_last_hidden_state, 可選: generator_enc_hidden_states, 可選: generator_enc_attentions)。形狀為 (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，可選，預設為 True) — 如果設定為 True，則返回 past_key_values 鍵值狀態，可用於加速解碼（參見 past_key_values）。
  • output_attentions (bool，可選) — 是否返回所有注意力層的注意力張量。更多詳情請參見返回張量下的 attentions。
  • output_hidden_states (bool，可選) — 是否返回所有層的隱藏狀態。更多詳情請參見返回張量下的 hidden_states。
  • output_retrieved(bool， 可選) — 是否返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。更多詳情請參見返回張量。
  • return_dict (bool，可選) — 是否返回 TFRetrievAugLMOutput 而不是普通元組。
  • n_docs (int，可選，預設為 `config.n_docs“) — 要檢索的文件數量和/或要生成答案的文件數量。

返回

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

一個 transformers.models.rag.modeling_tf_rag.TFRetrievAugLMOutput 或一個 tf.Tensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False）包含根據配置 (RagConfig) 和輸入的不同元素。

  • logits (tf.Tensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數。該分數可能已對每個詞彙標記的所有文件進行邊際化。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解碼器預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • doc_scores (tf.Tensor，形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）與 question_encoder_last_hidden_state 之間的分數。

  • retrieved_doc_embeds (tf.Tensor，形狀為 (batch_size, config.n_docs, hidden_size)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件。與 question_encoder_last_hidden_state 一起用於計算 doc_scores。

  • retrieved_doc_ids (tf.Tensor，形狀為 (batch_size, config.n_docs)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件的索引。

  • context_input_ids (tf.Tensor，形狀為 (batch_size * config.n_docs, config.max_combined_length)，可選，當 output_retrieved=True 時返回) — 檢索器對檢索到的文件和問題編碼器 input_ids 進行後處理後的輸入 ID。

  • context_attention_mask (tf.Tensor，形狀為 (batch_size * config.n_docs, config.max_combined_length)，可選，當 output_retrieved=True 時返回) — 檢索器對檢索到的文件和問題編碼器 input_ids 進行後處理後的注意力掩碼。

  • question_encoder_last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型問題編碼器池化輸出的最後一層輸出的隱藏狀態序列。

  • question_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_enc_last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型生成器編碼器最後一層輸出的隱藏狀態序列。

  • generator_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 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 架構中用作生成器的 seq2seq 模型。
  • retriever (RagRetriever) — 一個封裝 faiss 索引的檢索器類，用於查詢以獲取當前輸入的上下文文件。

TFRagSequenceForGeneration 前向方法，覆蓋 __call__ 特殊方法。

雖然前向傳遞的配方需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

TF RAG-sequence 模型實現。它在正向傳遞中執行 RAG-sequence 特定的邊際化。

RAG 是一種序列到序列模型，它封裝了兩個核心元件：問題編碼器和生成器。在正向傳遞過程中，我們使用問題編碼器對輸入進行編碼，並將其傳遞給檢索器以提取相關的上下文文件。然後將這些文件預置到輸入中。這種上下文化輸入被傳遞給生成器。

問題編碼器可以是任何自編碼模型，最好是 TFDPRQuestionEncoder，生成器可以是任何seq2seq模型，最好是 TFBartForConditionalGeneration。

模型可以用 RagRetriever 初始化以實現端到端生成，或者與檢索器在多個步驟中輸出結合使用——有關更多詳細資訊，請參見示例。該模型相容任何自編碼模型作為 question_encoder，以及任何帶有語言模型頭的seq2seq模型作為 generator。它已經使用 TFDPRQuestionEncoder 作為 question_encoder 和 TFBartForConditionalGeneration 作為 generator 進行了測試。

此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視超類文件。

此模型也是 Tensorflow keras.Model 的子類。請將其作為常規的 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

該模型處於開發階段，因為它目前僅在 eager-mode 中完全支援，並且可能無法以 SavedModel 格式匯出。

呼叫

< >

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

引數

  • input_ids (tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。RagConfig 用於初始化模型，它指定要使用的生成器，也指定相容的生成器分詞器。使用該分詞器類獲取索引。
  • attention_mask (tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：

    • 1 表示未被掩蓋的標記，
    • 0 表示被掩蓋的標記。

    什麼是注意力掩碼？

  • encoder_outputs (tuple(tuple(tf.Tensor), 可選) — 元組包含 (generator_enc_last_hidden_state, 可選: generator_enc_hidden_states, 可選: generator_enc_attentions)。形狀為 (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, 可選，預設為 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`) — 要檢索的文件數量和/或要生成答案的文件數量。
  • exclude_bos_score (bool, 可選) — 僅當傳入 labels 時相關。如果為 True，則在計算損失時忽略 BOS 標記的分數。
  • labels (tf.Tensor 或 np.ndarray，形狀為 (batch_size, sequence_length)，可選) — 根據 Rag-Sequence 模型公式計算交叉熵分類損失的標籤。有關 Rag-Sequence 公式化細節，請參見 https://huggingface.co/papers/2005.11401 第 2.1 節。索引應在 [0, ..., config.vocab_size - 1] 範圍內。
  • reduce_loss (bool, 可選) — 僅當傳入 labels 時相關。如果為 True，則使用 tf.Tensor.sum 操作來減少 NLL 損失。
  • kwargs (dict[str, any], 可選，預設為 {}) — 舊版字典，為了模型能使用 generate() 函式而必需。

返回

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

一個 transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (RagConfig) 和輸入的不同元素。

  • loss (tf.Tensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。

  • logits (tf.Tensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數。該分數可能已對每個詞彙標記的所有文件進行邊際化。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解碼器預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • doc_scores (tf.Tensor，形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）與 question_encoder_last_hidden_state 之間的分數。

  • retrieved_doc_embeds (tf.Tensor，形狀為 (batch_size, config.n_docs, hidden_size)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件。與 question_encoder_last_hidden_state 一起用於計算 doc_scores。

  • retrieved_doc_ids (tf.Tensor (int32)，形狀為 (batch_size, config.n_docs)，可選，當 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 (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型問題編碼器池化輸出的最後一層輸出的隱藏狀態序列。

  • question_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_enc_last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型生成器編碼器最後一層輸出的隱藏狀態序列。

  • generator_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 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)

生成

< >

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

引數

  • input_ids (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()](/docs/transformers/v4.53.3/en/main_classes/text_generation#transformers.GenerationMixin.generate) 函式的值，在該函式中我們將 num_return_sequences 設定為 num_beams。
  • num_beams (int, 可選，預設為 1) — Beam 搜尋的束數。1 表示沒有束搜尋。
  • 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) — 一個與 retriever 封裝的 faiss 索引相容的編碼器模型。
  • generator (TFPreTrainedModel) — 在 RAG 架構中用作生成器的 seq2seq 模型。
  • retriever (RagRetriever) — 用於查詢以獲取當前輸入的上下文文件的檢索器類，封裝了一個 faiss 索引。

TFRagTokenForGeneration 的前向方法重寫了 __call__ 特殊方法。

雖然前向傳遞的配方需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。

TF RAG-token 模型實現。它在前向傳遞中執行 RAG-token 特定的邊緣化。

RAG 是一種序列到序列模型，它封裝了兩個核心元件：問題編碼器和生成器。在正向傳遞過程中，我們使用問題編碼器對輸入進行編碼，並將其傳遞給檢索器以提取相關的上下文文件。然後將這些文件預置到輸入中。這種上下文化輸入被傳遞給生成器。

問題編碼器可以是任何自編碼模型，最好是 TFDPRQuestionEncoder，生成器可以是任何seq2seq模型，最好是 TFBartForConditionalGeneration。

模型可以用 RagRetriever 初始化以實現端到端生成，或者與檢索器在多個步驟中輸出結合使用——有關更多詳細資訊，請參見示例。該模型相容任何自編碼模型作為 question_encoder，以及任何帶有語言模型頭的seq2seq模型作為 generator。它已經使用 TFDPRQuestionEncoder 作為 question_encoder 和 TFBartForConditionalGeneration 作為 generator 進行了測試。

此模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等），請檢視超類文件。

此模型也是 Tensorflow keras.Model 的子類。請將其作為常規的 TF 2.0 Keras 模型使用，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

該模型處於開發階段，因為它目前僅在 eager-mode 中完全支援，並且可能無法以 SavedModel 格式匯出。

呼叫

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: 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 ) → transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或 tuple(tf.Tensor)

引數

  • input_ids (tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。RagConfig 用於初始化模型，它還指定了相容的生成器 tokenizer。使用該 tokenizer 類獲取索引。
  • attention_mask (tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 掩碼，用於避免在填充標記索引上執行注意力。掩碼值選擇在 [0, 1]：

    • 1 表示未被掩碼的標記，
    • 0 表示被掩碼的標記。

    什麼是注意力掩碼？

  • encoder_outputs (tuple(tuple(tf.Tensor), 可選) — 元組包含 (generator_enc_last_hidden_state, 可選: generator_enc_hidden_states, 可選: generator_enc_attentions)。形狀為 (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, 可選，預設為 True) — 如果設定為 True，則返回 past_key_values 鍵值狀態，可用於加速解碼（請參見 past_key_values）。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參見返回張量下的 attentions。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參見返回張量下的 hidden_states。
  • output_retrieved(bool, 可選) — 是否返回 retrieved_doc_embeds、retrieved_doc_ids、context_input_ids 和 context_attention_mask。更多詳細資訊請參見返回張量。
  • return_dict (bool, 可選) — 是否返回 TFRetrievAugLMOutput 而不是普通元組。
  • n_docs (int, 可選, 預設為 `config.n_docs“) — 要檢索的文件數量和/或要生成答案的文件數量。
  • do_marginalize (bool, 可選) — 如果為 True，則使用 torch.nn.functional.log_softmax 對所有文件的 logits 進行邊際化處理。
  • labels (tf.Tensor 或 np.ndarray，形狀為 (batch_size, sequence_length)，可選) — 根據 Rag-Token 模型公式計算交叉熵分類損失的標籤。有關 Rag-Token 公式詳情，請參閱 https://huggingface.co/papers/2005.11401 第 2.1 節。索引應在 [0, ..., config.vocab_size - 1] 範圍內。
  • reduce_loss (bool, 可選) — 僅當傳入 labels 時相關。如果為 True，則使用 tf.Tensor.sum 操作減少 NLL 損失。
  • kwargs (dict[str, any], 可選, 預設為 {}) — 舊版字典，為了使模型能夠使用 generate() 函式而必需。

返回

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

一個 transformers.models.rag.modeling_tf_rag.TFRetrievAugLMMarginOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (RagConfig) 和輸入的不同元素。

  • loss (tf.Tensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。

  • logits (tf.Tensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數。該分數可能已對每個詞彙標記的所有文件進行邊際化。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解碼器預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • doc_scores (tf.Tensor，形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）與 question_encoder_last_hidden_state 之間的分數。

  • retrieved_doc_embeds (tf.Tensor，形狀為 (batch_size, config.n_docs, hidden_size)，可選，當 output_retrieved=True 時返回) — 檢索器檢索到的嵌入文件。與 question_encoder_last_hidden_state 一起用於計算 doc_scores。

  • retrieved_doc_ids (tf.Tensor (int32)，形狀為 (batch_size, config.n_docs)，可選，當 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 (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型問題編碼器池化輸出的最後一層輸出的隱藏狀態序列。

  • question_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    問題編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • question_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    問題編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_enc_last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型生成器編碼器最後一層輸出的隱藏狀態序列。

  • generator_enc_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器編碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_enc_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭部中的加權平均。

  • generator_dec_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    生成器解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。

  • generator_dec_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    生成器解碼器的注意力權重，在注意力 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)

生成

< >

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None context_input_ids = None context_attention_mask = None doc_scores = None n_docs = None generation_config = None logits_processor = [] **kwargs ) → tf.Tensor 形狀為 (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)，可選) — 用於避免對填充 token 索引執行注意力操作的掩碼。掩碼值選擇在 [0, 1] 之間：

    • 1 表示**未被掩碼**的 token，
    • 0 表示**被掩碼**的 token。

    什麼是注意力掩碼？

  • context_input_ids (tf.Tensor，形狀為 (batch_size * config.n_docs, config.max_combined_length)，可選，當 output_retrieved=True 時返回) — 由檢索器從檢索到的文件和問題編碼器 input_ids 後處理得到的輸入 ID。

    如果模型未用 retriever 初始化，則必須向正向傳遞提供 context_input_ids。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_input_ids。context_input_ids 由 __call__() 返回。

  • doc_scores (tf.Tensor，形狀為 (batch_size, config.n_docs)) — 每個檢索到的文件嵌入（參見 retrieved_doc_embeds）與 question_encoder_last_hidden_state 之間的分數。

    如果模型未用 retriever 初始化，則必須向正向傳遞提供 context_input_ids。context_input_ids 由 __call__() 返回。

  • n_docs (int, 可選, 預設為 config.n_docs) — 要檢索的文件數量和/或要生成答案的文件數量。
  • generation_config (~generation.GenerationConfig, 可選) — 用作生成呼叫基本引數化的生成配置。傳入 generate 的與 generation_config 屬性匹配的 **kwargs 將覆蓋它們。如果未提供 generation_config，將使用預設值，其載入優先順序如下：1) 如果存在，從 generation_config.json 模型檔案載入；2) 從模型配置載入。請注意，未指定的引數將繼承 GenerationConfig 的預設值，應查閱其文件以引數化生成。
  • logits_processor (TFLogitsProcessorList, 可選) — 補充從引數和模型配置構建的預設 logits 處理器的自定義 logits 處理器。如果傳入已使用引數或模型配置建立的 logits 處理器，則會丟擲錯誤。
  • 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 token 解碼。

< > 在 GitHub 上更新

←Qwen3MoE REALM→
© . This site is unofficial and not affiliated with Hugging Face, Inc.