BIDER: Bridging Knowledge Inconsistency for Efficient Retrieval-Augmented LLMs via Key Supporting Evidence (2024)

Abstract: Retrieval-augmented large language models (LLMs) have demonstrated efficacy in knowledge-intensive tasks such as opendomain QA, addressing inherent challenges in knowledge update and factual inadequacy. However, inconsistencies between retrieval knowledge and the necessary knowledge for LLMs, leading to a decline in LLM’s answer quality. This paper introduces BIDER, an approach that refines retrieval documents into Key Supporting Evidence (KSE) through knowledge synthesis, supervised fine-tuning (SFT), and preference alignment. We train BIDER by learning from crafting KSE, while maximizing its output to align with LLM’s information acquisition preferences through reinforcement learning. Evaluations across five datasets show BIDER boosts LLMs’ answer quality by 7% while reducing input content length in retrieval documents by 80%, outperforming existing methods. The proposed KSE simulation effectively equips LLMs with essential information for accurate question answering.

heading: 1 Introduction
text: Large language models (LLMs) are currently developing rapidly and showing tremendous capabilities (OpenAI, 2023; Touvron et al., 2023). Nevertheless, they face challenges in knowledge updates and furnishing factual responses (Bang et al., 2023), especially in knowledge-intensive tasks like open-domain QA (Jiang et al., 2023b). To address these issues, retrieval-augmented generation (RAG) has emerged as a promising approach (Lewis et al., 2020; Guu et al., 2020; Tan et al., 2024). Retrievalaugmented methodologies serve to mitigate the drawbacks of LLMs by incorporating external knowledge, thereby enhancing the quality and reliability of generated answers (Izacard et al., 2023; Shi et al., 2023b; Press et al., 2023).
∗*Corresponding author
The standard RAG procedure involves retrieving pertinent documents related to a given question and subsequently inputting these documents as auxiliary information directly into the prompt. This strategic utilization enables the model to capitalize on its advanced text comprehension skills, facilitating the generation of precise and contextually appropriate answers.
However, retrieval-augmented LLMs are not always beneficial. Due to imperfections in the retrieval system and the inaccessibility of LLM’s self-knowledge (Wang et al., 2023b), the retrieved documents provided to LLM are frequently lengthy and noisy, which can detrimentally affect generation quality (Petroni et al., 2020; Shi et al., 2023a).
Recognizing this decline, recent researches have made strides in optimizing retrieved documents. These efforts aim to mitigate noise in retrieved documents by employing sorting mechanisms to retain the most pertinent sentences (Xu et al., 2023; Arefeen et al., 2023), summarizing the retrieved text (Xu et al., 2023), and eliminating content that contributes minimally to the model’s understanding (Li, 2023; Jiang et al., 2023a) or hinders effective generation (Yang et al., 2023).
While prior methods have shown progress in enhancing the quality of retrieved documents, they often rely excessively on feedback from the generator, overlooking the essential knowledge required
750
for addressing the questions themselves. This overreliance on LLM’s feedback is not only insufficient but also susceptible to the instability of LLM feedback, potentially resulting in the loss of crucial information and the retention of noisy elements. We argue that this limitation might stem from the neglect of knowledge inconsistency between the retrieved results and the knowledge truly required by the model for answering the question. We term this essential knowledge as Key Supporting Evidence (KSE). As shown in Figure 1, due to the imperfections of the retrieval system and the inaccessibility of LLM’s self-knowledge (Wang et al., 2023b), retrieved results often contain numerous noise elements beyond key supporting evidence.
To address the aforementioned knowledge inconsistency issue, we propose BIDER(BrIDging knowledge inconsistency for efficient Retrievalaugmented LLMs), a method designed to refine retrieval documents into KSE. The overall training process of BIDER consists of three stages, integrating the strengths of both supervised and reinforcement learning, as shown in Figure 2. In the knowledge synthesizing stage, we employ a meticulous three-step process to synthesize authentic KSE. In the supervised fine-tuning stage, we construct a seq2seq model to learn the mapping from retrieved documents to KSE. Finally, in the preference alignment stage, we leverage reinforcement learning techniques to align the developed model with the preferences of the downstream LLM. This alignment ensures that the refined retrieval documents contain coherent and easily digestible key information, which is crucial for the LLM to generate accurate and informative responses.
We evaluate the effectiveness of our method on five datasets from three types of knowledgeintensive tasks, i.e., NQ, TQA, and HotpotQA for open-domain QA, WoW for dialogue generation, and FEVER for fact verification. Results show that our method achieves better generation performance while reducing the input information length by 80%, effectively condensing retrieved documents, and outperforming existing methods. We also validate the advantages of our proposed KSE data construction process and investigate the impact of the preference alignment stage on the final results. Furthermore, we validate the robustness of our approach under various text retrieval quality conditions.
The main contributions of this work are: (1) We
propose a three-step knowledge synthesis method to generate oracle KSE. (2) We introduce a method to refine retrieval documents into KSE, thereby bridging knowledge inconsistencies between retrieval documents and the knowledge required by LLMs for answering. (3) We train the refiner model using supervised distillation and preference alignment techniques, efficiently enhancing RAG performance during inference by reducing input length and improving answer quality.

heading: 2 Related Work

heading: 2.1 RAG for LLMs
text: In knowledge-intensive tasks (Petroni et al., 2021), RAG (Lewis et al., 2020) has been introduced to enhance generative outcomes by incorporating external knowledge sources. In previous work, the retriever and generator are usually jointly trained end-to-end (Guu et al., 2020; Lewis et al., 2020; Borgeaud et al., 2022). With the advent of LLMs (OpenAI, 2023; Touvron et al., 2023; Zhu et al., 2024), most works now directly use them as generators due to their strong text comprehension ability, without the need for additional training (Jiang et al., 2023b; Yao et al., 2023; Shinn et al., 2023). While this approach demonstrates efficiency, it introduces new challenges, including susceptibility to interference from irrelevant content (Shi et al., 2023a; Bai et al., 2023; Mallen et al., 2022), insufficient attention to middle positions (Liu et al., 2023), and increased inference costs (Dettmers et al., 2022). Our method refines retrieved documents to eliminate noise, significantly reducing the input required for inference. By learning information retrieval preferences from LLM feedback, it provides the LLM with text that is more informative and easily captures relevant information, offering a substantial solution to the aforementioned issues.

heading: 2.2 Knowledge Refinement for RAG
text: Recent works leverage the capabilities of LLMs to identify pertinent information from various perspectives. Some approaches directly task the LLM with summarizing retrieval documents to identify pertinent information (Laskar et al., 2023; Chen et al., 2023; Gilbert et al., 2023; Xu et al., 2023). Moreover, certain methods employ smaller models to calculate perplexity as an importance indicator for filtering low-information text (Li, 2023; Jiang et al., 2023a). Xu et al. (2023) employ the LLM
to assess the utility of each sentence in retrieval documents, using this information as labels to train a ranking model. Other works leverage LLM feedback for training; for instance, Arefeen et al. (2023) train a ranking model using reinforcement learning to retain top-ranked sentences, and Yang et al. (2023) design a reward mechanism to train a refinement model for retrieval documents. While these methods are effective, they are constrained by the instability of LLM feedback, providing limited guidance on specific information deemed valuable, which results in inefficient and suboptimal training outcomes. In contrast, our method employs well-designed key supporting evidence as a training objective, allowing the refiner to learn knowledge comprehensively before reinforcement learning, ensuring the provision of knowledge that better aligns with the LLM’s needs. In summary, our approach offers two main advantages over these methods: (1) Broader practical application: our method not rely on annotated sentences or evidence, requiring only a golden answer to extract training targets; (2) Overall better performance: Our method optimizes both the SFT and RL phases, emphasizing the importance of their synergy, and can achieving better performance.

heading: 3 BIDER: a Knowledge Refiner for RAG
text: Our objective is to furnish the necessary knowledge for a generator, specifically the KSE as defined earlier, to answer a question. Since authentic KSE is unattainable, we employ a synthesize-and-learn paradigm. We design a method for synthesizing authentic KSE, training the refiner to learn the map from retrieval documents to constructed KSE, and adapting the model’s information acquisition preferences based on the generator’s feedback.
The overall framework of BIDER is illustrated in Figure 2. In this section, we first formulate the research problem (§3.1). Then, we introduce the details of three training stages of BIDER, including Knowledge Synthesis (§3.2), Supervised Distillation (§3.3), and Preference Alignment (§3.4).

heading: 3.1 Problem Formulation
text: In this problem, we assume that a document collection C, a fixed retriever R, and a fixed generator G are provided. For a given question q and its corresponding golden answer o, we assume that K documents are retrieved by retriever R, denoted as Dq = {di}Ki=1. In the naive RAG framework, Dq is directly incorporated into the generator’s input to obtain the output answer. We aim to find the optimal mapping function F∗ for the retrieved documents Dq, in order for the generator G to use F∗(Dq) and achieve the best output results. We
design BIDER to act as the mapping function, refining retrieval documents to make them more suitable for the input preferences of the generator.

heading: 3.2 Knowledge Synthesis Stage
text: We design a three-step method to gradually synthesize authentic KSE.
(1) Nugget Extraction. We initially narrow down the scope of knowledge helpful for answering by extracting nuggets from the retrieval documents. Here a nugget can be a sentence, a passage, or even a key phrase. In this paper, we use sentences as nuggets because using sentences already yields robust and consistent results. We will explore approaches with different nugget granularities in our future work. For each input question q and its corresponding golden answer o, we first formulate them into a fact f = concat(q, o) to ensure comprehensive semantic representation.1 Then, we use f as the query to perform sentence-level nugget retrieval in the retrieved documents Dq to remove noise and retain helpful sentences. In nugget retrieval, Dq is split into nuggets and transformed into vectors, while the query is vectorized. Based on the similarity between the query vector and nugget vectors, we obtain a positive nugget set S including retrieved top K nuggets:
S = TopK s∈Dq (sim(s, f)). (1)
Here, sim(·, ·) represents the function for calculating semantic similarity by the E5 model (Wang et al., 2022), and K is a hyperparameter. A larger K can improve the recall of relevant information in Dq, but it also raises the risk of including more irrelevant information.
(2) Nugget Refinement. While the extraction step effectively reduces noise in retrieved documents, there may be redundancy in S. Therefore, we further design an iterative selection method to retain the minimal nugget subset necessary for answering the question.
Initially, we set up a candidate pool P . In each round, we calculate a gain score for each nugget in S, which represents the degree of assistance in answering the question. The gain score is defined as follows:
κi = sim(si, f)− 1 |P| ∑
sj∈P sim(si, sj). (2)
1For FEVER and HotpotQA where the answers have no actual semantic meaning, we use annotated evidence as a golden answer to ensure more accurate semantic information.
This takes into account the importance of the nugget itself as well as its duplication with the already-selected nuggets. Then, we select the sentence with the highest κi from S and move it to the candidate pool P . After moving, we use an NLI model to measure to what extent the candidate pool P can support answering q, i.e., yielding a support degree ηk in k-th nugget selection.
The iterative selecting process will terminate in two cases: (1) when the support degree ηk exceeds λmax; (2)when the difference in support degree between two rounds, ηk − ηk−1, is less than λmin, where λmax and λmin are predefined thresholds. This aims to avoid introducing redundant information, especially in scenarios where retrieval documents fail to furnish adequate information, such as instances where the retriever’s quality is subpar or when the posed question is challenging.
(3) Nugget Cleaning. The candidate pool P from the previous stage serves as the minimal subset of information necessary for answering. However, we have yet to consider the knowledge intrinsic to the generator itself, which encompasses information either known by LLM or detrimental to its generation. To mitigate conflicts arising from the disparity between external and internal knowledge, we conduct nugget cleaning in the candidate pool. In our experiments, we observe that the first nugget within the candidate pool is usually important. To avoid unintentionally removing vital information, we retain the first nugget directly and perform nugget cleaning for the left set.
For each nugget si(i ≥ 2) in P , we assess its influence on the generator by determining whether it contributes to the model’s output improvement when utilized as input. Specifically, we calculate the change in the log probability of generating the correct answer o between the model’s output before and after the inclusion of the nugget. This score for each nugget si is denoted as
τ ′i = log G(o|q ⊕ si)
G(o|q) , i ≥ 2. (3)
where G represents the generator. Subsequently, we normalize all scores within the candidate pool to derive the final score τi:
τi = τ ′i∑|P| j=2 τ ′ j , i ≥ 2. (4)
Nuggets with scores below λlm are deemed unhelpful or potentially detrimental to the generator’s
response and are consequently excluded from the candidate pool. The surviving nuggets in the filtered candidate pool represent the ultimate oracle KSE, which correspond to the distillation results for each sample triplet (q, o,Dq).

heading: 3.3 Supervised Distillation Stage
text: In this stage, we aim to develop BIDER to acquire the ability to comprehend the relationship between retrieval documents and oracle KSE. This enhancement will enable BIDER to effectively refine its output during inference, particularly when provided only with the question.
A common approach is to consider this as a ranking task (Xu et al., 2023; Liu, 2019), using the nuggets extracted in the previous section as positive examples and other nuggets as negative examples for training the ranker. Although this method can relatively stably filter information, it is not able to effectively generate content that can adapt to the input of the generation model, as the refined content can only come from the original text.
We model the task as a seq2seq task, which is similar to the idea of pointer network (See et al., 2017; Gu et al., 2016). This method ensures the flexibility of refinement while enhancing the potential of the generation model in expression. Meanwhile, this serialization modeling approach makes it easier for the model to capture the generated sentences during generation. In Section 5.1, we will compare the two methods and demonstrate the effectiveness of our approach.
We use a pre-trained seq2seq model as the backbone model. For each sample triplet (q, o,Dq), the refiner model’s input is the concatenation of the question and the original retrieval document: q ⊕ Dq. For ease of processing, we add separators between each document in Dq and merge them into one string. The target output of the model is the P extracted in the Knowledge Synthesis Stage, where each nugget is merged into one string in order. The training loss function of the model is the cross-entropy loss between the model output and the target output.

heading: 3.4 Preference Alignment Stage
text: Inspired by the RLHF technology (Ziegler et al., 2019; Stiennon et al., 2020; Ouyang et al., 2022), we further enhance the adaptability of BIDER by incorporating feedback from a downstream LLM. Reinforcement learning enables the generative model
to discern which nuggets are effective, thereby mitigating the possible risk of noise introduction in the knowledge synthesis phase. This complements our knowledge synthesis stage and helps our trained refiner better understand the context.
Specifically, we model the optimization problem of the model as a RL problem, with the objective to generate content that conforms to the LLM’s information acquisition preferences without losing its original information capturing ability. The refiner model M to be optimized acts as a policy, where its action space encompasses all tokens in the vocabulary. We use the CLIP version of the PPO algorithm (Schulman et al., 2017) for optimization, which uses CLIP to control the magnitude of model updates. The loss function consists of three parts:
LALLt = Et[L CLIP t − LVFt + LBONUSt ]. (5)
LCLIPt is the primary objective function for optimizing the policy at step t, expressed as:
LCLIPt = min(rtÂt, clip(rt, 1− ϵ, 1 + ϵ)Ât (6)
rt = πθ(y|x) πold(y|x) , (7)
where ϵ is a hyperparameter to control the policy update magnitude, rt represents the conditional generation probability ratio between the new policy and the old policy, and At denotes the estimated value of the advantage function at step t, calculated from Generalized Advantage Estimation (GAE) (Schulman et al., 2016):
Ât = T−t+1∑
l=0
(γλ)l (Rt + γV (st+1)− V (st)) ,
where γ and λ are hyperparameters. V represents the critic network used to estimate expected rewards, and Rt indicates the reward at step t. LVFt (θ) is the squared error between the predicted reward and the actual reward output by the critic network, used to fit the critic network:
LVFt (θ) = (Vθ(st)−Rt)2. (8)
LBONUSt (θ) is an entropy bonus designed to ensure the model can explore sufficiently.
To calculate the above loss, we need a welldefined reward function Rt. Considering that the downstream LLM is highly sensitive to the overall information density and the position of key information, providing rewards before all sentences are
generated could lead to inaccurate guidance. Thus, we design a segmented reward function:
Rt = { 0, st ̸= ⟨EOF⟩, F1(apred, o)− F1(aori, o), st = ⟨EOF⟩.
where apred and aori represent the answers generated by LLM based on the refiner result and original retrieval result respectively , ⟨EOF⟩ represents the end-of-sentence symbol. We generate answers from the LLM using the original document and refined results separately as references, and evaluate the quality of the refiner’s distillation of the retrieved document by comparing the token-level F1 scores of these two types of answers with the golden answer.

heading: 4 Experimental Setup

heading: 4.1 Datasets and Metrics
text: We experiment on five datasets of three knowledgeintensive tasks in the KILT benchmark (Petroni et al., 2021): (1) Open-domain QA, including NaturalQuestions (NQ) (Kwiatkowski et al., 2019), TriviaQA (TQA) (Joshi et al., 2017),and HotpotQA (Yang et al., 2018); (2) Dialog Generation, including the Wizard of Wikipedia (WoW)(Dinan et al., 2019), where the generator is tasked with continuing the dialogue based on the preceding conversation history; (3) Fact-checking, including FEVER(Thorne et al., 2018) that classifies a given claim as "SUPPORTS" or "REFUTES".
We use Exact Match (EM) as the evaluation metric for NQ and TQA, use accuracy for FEVER, and use token-level F1 (Jiang et al., 2023b) for HotpotQA and Wow. Evaluation is conducted on top 1000 samples in the test set of NQ, TQA, and HotpotQA, while on the development set of FEVER and WoW. Table 2 provides detailed sample sizes and the evaluation metrics used for each dataset.

heading: 4.2 Baselines
text: We compare with two types of baselines.
Extractive Methods: We employ three retrieval methods to extract sentences from retrieval documents, including BM25 (Xu et al., 2023), SentenceBERT (Reimers and Gurevych, 2019), and LLMEmbedder (Zhang et al., 2023) which is trained with contrastive learning and feedback from LLM. To demonstrate the superiority of modeling the task as a seq2seq problem in the supervised distillation stage, we fine-tuned the bge-reranker-large (Xiao et al., 2023) for comparison.
Abstractive Methods: BART-Large is utilized for summarization (Lewis et al., 2019a), along with two state-of-the-art perplexity-based prompt refinement models: Selective Context (Li, 2023) and LongLLMLingua (Jiang et al., 2023a). Additionally, we include the RECOMP (Xu et al., 2023) method trained using distillation data from GPT3.5 as a baseline.

heading: 4.3 Implementation Details
text: The size of the positive nugget set K is set to 7. We utilize a T5-XXL model as the NLI model with the threshold λmax set to 0.5, λmin set to 0.01,λlm set to 0.05.2 We utilized BART-Large (Lewis et al., 2019b) as the base model for BIDER. During training, we utilize AdamW (Loshchilov and Hutter, 2019) as the optimizer with a learning rate of 5e-5, and a batch size of 32. In the preference alignment stage, topk is set to 10, and topp is set to 0.95. The training is implemented with HuggingFace Transformers (Wolf et al., 2020) and PFRL (Fujita et al., 2021). We use the December 2018 Wikipedia dump (Karpukhin et al., 2020; Lin et al., 2021) as retrieval corpus, BM25 as retriever, and SimLM as reranker (Wang et al., 2023a) for the top 100 documents returned by the retriever. LLAMA27B (Touvron et al., 2023) is utilized as the generator to provide answers.
For training for BGE-Reranker, we followed the fine-tuning procedure provided by the official FlagEmbedding repository.3 The learning rate was set to 6e-5. We trained for five epochs with a batch size of 1 per device, and gradient accumulation steps were set to four. For the training data, only the top-ranked nuggets selected by us were labeled as positive examples, while the rest were marked as negative.

heading: 5 Experimental Results

heading: 5.1 Main Results
text: Table 1 reports the results of our approach alongside baseline methods on five knowledge-intensive datasets. It can be observed that our method outperforms the baseline on all datasets except FEVER, showcasing a notable performance advantage over other existing approaches, demonstrating around a 10% performance increase on all datasets. We also observe a relatively small performance gap on the
2https://huggingface.co/google/t5_xxl_true_nl i_mixture
3https://github.com/FlagOpen/FlagEmbedding
FEVER dataset, indicating a potential weakness in the model’s ability to leverage retrieval documents for text-based verification tasks. Compared to the original prompt, our method refines the retrieval documents to 20% of their original length, achieving an average improvement of approximately 8%. Notably, on the WoW dataset, the improvement approaches nearly 40%.
Comparison with extractive methods. The overall performance of extractive methods is quite satisfactory. Fine-tuning bge-reranker with our KSE extraction yielded the best results, indicating the effectiveness of our extracted KSE. However, there still exists a discernible gap between this approach and ours, possibly highlighting the influence of the preference alignment stage and model structure.
Comparison with abstractive methods. Abstractive refinement methods like Selective-Context and LongLLMLingua show a significant performance gap compared to our approach, particularly
in QA tasks. This may result from their reliance on perplexity-based computations, posing a risk of losing essential entity information crucial for answering questions during refinement. In contrast, our method minimizes the risk of token-level information loss by employing sentence-level processing in data construction. Compared to RECOMP, our model demonstrates better performance, albeit with higher token usage. It seems that models trained on data distilled from GPT3.5 can be quite effective, but come with substantial annotation costs. In contrast, our method shows better overall results with considerably lower training costs, relying merely on locally deployed smaller models for target extraction.

heading: 5.2 Evaluation on Knowledge Synthesis Stage
text: To explore the necessity and effectiveness of the three steps in the knowledge synthesis stage, we use the results of each step as reference inputs for generating answers. For a comprehensive comparison, we incorporate results from the extraction based on the similarity between golden evidence and sentences in the retrieved documents.
As illustrated in Figure 3, with the further refinement of the retrieved text in the knowledge synthesis stage, the length of the input to the generator significantly decreases. However, there is a notable improvement in the quality of the LLM’s
responses. This observation indicates the effectiveness of our approach in reducing noise in the retrieved text, providing the generator with more easily exploitable information. Simultaneously, it is observed that directly using golden evidence as the target for information extraction results in an inferior performance. Overall, the effectiveness is somewhat lower compared to our second step. This suggests that relying solely on the relationship between the text and the question/answer for data extraction is insufficient, and it’s necessary to consider the knowledge of the model itself when constructing the data.

heading: 5.3 Ablation Study
text: To assess the impact of BIDER’s key components, we performed ablation experiments on NQ and TQA. Two variants were introduced for study: i) BIDER w/o preference alignment, using models without reinforcement learning, and ii) BIDER w/o knowledge synthesis, replacing knowledge synthesis method with a naive sentence-level retrieval method as the training target for SFT.
Table 3 displays the results, emphasizing a decline in performance when either component is removed. This underscores the indispensability of both components. Particularly, the impact on
performance due to the absence of the knowledge synthesis method is more significant than that of the preference alignment part. This implies that the construction of the training target in the initial phase is more crucial than preference alignment. Hence, emphasizing the construction of training data in the first phase should be a priority, rather than relying solely on LLM feedback for learning.

heading: 5.4 Impact of Preference Alignment
text: To further investigate the impact of preference alignment, we analyzed model output before and after this stage, specifically focusing on effective information content and its optimal sequence. We measured the proportion of golden answers in the generated results and their average position on a sentence level for models trained through supervised learning and those additionally trained with preference alignment.
Table 4 presents the results, indicating that after preference alignment training, the proportion of golden answers in the model output increased by 3%-4%, and their position in the output text moved closer to the beginning. This improvement suggests a dual effect: an augmentation in information content and a repositioning of crucial information towards the text’s forefront.

heading: 5.5 Impact of Retrieval Quality
text: We directly utilize top 5 retrieval documents from BM25(without reranker) to demonstrate generalizability on weaker retrievers. As depicted in Table 5,
our approach performs well under different quality retrievers, surpassing other methods. And it can be observed that our method brings more improvements when the retriever quality is worse, indicating the effectiveness of our refinement method.

heading: 5.6 Inference Latency
text: Table 6 shows the inference latency of various components within the system on a V100-32G GPU. It is observed that the time required for text refinement using BIDER is notably short, facilitating effective support for applications in the RAG scenario. Additionally, as the refined input to the generator is shorter, the time taken by the generator to produce responses has also decreased. Consequently, there is a 10% enhancement in the overall end-to-end speed.

heading: 6 Conclusion
text: We present BIDER, a method to refine retrieved documents into KSE, addressing inconsistencies between retrieved results and the knowledge needed by the generator. We designed a three-step process to synthesize authentic key supporting evidence to enhance the effectiveness of supervised learning, while utilizing LLM’s feedback for further alignment. Through a well-structured training process, BIDER effectively provides the generator with the necessary information to answer questions based on the original retrieval text, achieving a significant improvement in answer quality while reducing input length by 80%.
Limitations
Our approach has some limitations. It performs less effectively in complex datasets like HotpotQA compared with NQ and TQA, suggesting that additional factors need to be considered for complex tasks. Also, our method requires separate training for each dataset and generator, limiting its use across different tasks and generators. Lastly, our datasets are based solely on Wikipedia, while realworld RAG applications involve diverse sources with varied writing styles. Optimizing for this diversity may require further refinement.

heading: Acknowledgments
text: This work was supported by Beijing Natural Science Foundation No. L233008, National Natural Science Foundation of China No. 62272467, the fund for building world-class universities (disciplines) of Renmin University of China, and Public Computing Cloud, Renmin University of China. The work was partially done at the Engineering Research Center of Next-Generation Intelligent Search and Recommendation, MOE.

heading: Future Work
text: We will explore approaches with different nugget granularities in our future work. For each input question q and its corresponding golden answer o, we first formulate them into a fact f = concat(q, o) to ensure comprehensive semantic representation. 1 Then, we use f as the query to perform sentence-level nugget retrieval in the retrieved documents Dq to remove noise and retain helpful sentences. In nugget retrieval, Dq is split into nuggets and transformed into vectors, while the query is vectorized. Based on the similarity between the query vector and nugget vectors, we obtain a positive nugget set S including retrieved top K nuggets:
S = TopK s∈Dq (sim(s, f)). (1)
Here, sim(·, ·) represents the function for calculating semantic similarity by the E5 model (Wang et al. , 2022), and K is a hyperparameter. A larger K can improve the recall of relevant information in Dq, but it also raises the risk of including more irrelevant information. (2) Nugget Refinement. While the extraction step effectively reduces noise in retrieved documents, there may be redundancy in S. Therefore, we further design an iterative selection method to retain the minimal nugget subset necessary for answering the question. Initially, we set up a candidate pool P. In each round, we calculate a gain score for each nugget in S, which represents the degree of assistance in answering the question. The gain score is defined as follows:
κi = sim(si, f)− 1 |P| ∑
sj∈P sim(si, sj). (2)
1For FEVER and HotpotQA where the answers have no actual semantic meaning, we use annotated evidence as a golden answer to ensure more accurate semantic information. This takes into account the importance of the nugget itself as well as its duplication with the already-selected nuggets. Then, we select the sentence with the highest κi from S and move it to the candidate pool P. After moving, we use an NLI model to measure to what extent the candidate pool P can support answering q, i. e. , yielding a support degree ηk in k-th nugget selection. The iterative selecting process will terminate in two cases: (1) when the support degree ηk exceeds λmax; (2)when the difference in support degree between two rounds, ηk − ηk−1, is less than λmin, where λmax and λmin are predefined thresholds. This aims to avoid introducing redundant information, especially in scenarios where retrieval documents fail to furnish adequate information, such as instances where the retriever’s quality is subpar or when the posed question is challenging. (3) Nugget Cleaning. The candidate pool P from the previous stage serves as the minimal subset of information necessary for answering. However, we have yet to consider the knowledge intrinsic to the generator itself, which encompasses information either known by LLM or detrimental to its generation. To mitigate conflicts arising from the disparity between external and internal knowledge, we conduct nugget cleaning in the candidate pool. In our experiments, we observe that the first nugget within the candidate pool is usually important. To avoid unintentionally removing vital information, we retain the first nugget directly and perform nugget cleaning for the left set. For each nugget si(i ≥ 2) in P , we assess its influence on the generator by determining whether it contributes to the model’s output improvement when utilized as input. Specifically, we calculate the change in the log probability of generating the correct answer o between the model’s output before and after the inclusion of the nugget. This score for each nugget si is denoted as
τ ′i = log G(o|q ⊕ si)
G(o|q) , i ≥ 2. (3)
where G represents the generator. Subsequently, we normalize all scores within the candidate pool to derive the final score τi:
τi = τ ′i∑|P| j=2 τ ′ j , i ≥ 2. (4)
Nuggets with scores below λlm are deemed unhelpful or potentially detrimental to the generator’s
response and are consequently excluded from the candidate pool. The surviving nuggets in the filtered candidate pool represent the ultimate oracle KSE, which correspond to the distillation results for each sample triplet (q, o,Dq)