ARL2: Aligning Retrievers for Black-box Large Language Models via Self-guided Adaptive Relevance Labeling (2024)

Abstract: Retrieval-augmented generation enhances large language models (LLMs) by incorporating relevant information from external knowledge sources. This enables LLMs to adapt to specific domains and mitigate hallucinations in knowledge-intensive tasks. However, existing retrievers are often misaligned with LLMs due to their separate training processes and the black-box nature of LLMs. To address this challenge, we propose ARL2, a retriever learning technique that harnesses LLMs as labelers. ARL2 leverages LLMs to annotate and score relevance evidence, enabling learning the retriever from robust LLM supervision. Furthermore, ARL2 uses a adaptive self-training strategy for curating high-quality and diverse relevance data, which can effectively reduce the annotation cost. Extensive experiments demonstrate the effectiveness of ARL2, achieving accuracy improvements of 5.4% on NQ and 4.6% on MMLU compared to the state-ofthe-art methods. Additionally, ARL2 exhibits robust transfer learning capabilities and strong zero-shot generalization abilities.

text: Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 3708–3719 August 11-16, 2024 ©2024 Association for Computational Linguistics
Retrieval-augmented generation enhances large language models (LLMs) by incorporating relevant information from external knowledge sources. This enables LLMs to adapt to specific domains and mitigate hallucinations in knowledge-intensive tasks. However, existing retrievers are often misaligned with LLMs due to their separate training processes and the black-box nature of LLMs. To address this challenge, we propose ARL2, a retriever learning technique that harnesses LLMs as labelers. ARL2 leverages LLMs to annotate and score relevance evidence, enabling learning the retriever from robust LLM supervision. Furthermore, ARL2 uses a adaptive self-training strategy for curating high-quality and diverse relevance data, which can effectively reduce the annotation cost. Extensive experiments demonstrate the effectiveness of ARL2, achieving accuracy improvements of 5.4% on NQ and 4.6% on MMLU compared to the state-ofthe-art methods. Additionally, ARL2 exhibits robust transfer learning capabilities and strong zero-shot generalization abilities.

heading: 1 Introduction
text: Retrieval-augmented generation (RAG) is a widely used technique for tailoring large language models (LLMs) (OpenAI, 2023; Anil et al., 2023; Touvron et al., 2023) to specific domains and tasks. By incorporating information from external knowledge sources, RAG enhances LLMs by prompting them with relevant evidence (Lewis et al., 2020; Izacard et al., 2022b; Shi et al., 2023b), without the need for expensive fine-tuning (He et al., 2023). These knowledge sources serve as a non-parametric reference, allowing LLMs to access up-to-date and customized corpora for answering questions. RAG has shown promising results in improving LLM response accuracy for target tasks, while also helping to mitigate LLM hallucination (Ji et al., 2023).
The practice of RAG for state-of-the-art LLMs often involves directly using standard retrievers (e.g. Google Search (Lazaridou et al., 2022), BM25 (Robertson et al., 2009)) or off-the-shelf dense retrievers (e.g., DPR (Karpukhin et al., 2020a), Contriever (Izacard et al., 2022a)) trained with supervised relevance signals. However, the performance of these methods is limited by the mismatch between the retrieval and downstream tasks, as the retrieved similar documents may not always be useful for the queries despite their relevance. In fact, retrieved documents with similar topics but irrelevant content may even mislead the LLM’s predictions (Yu et al., 2023b; Shi et al., 2023a).
To address the challenge of adapting retrievers for LLMs, several works propose joint training of retrievers and language models (Izacard et al., 2022b; Lin et al., 2023b; Cheng et al., 2023). However, these methods require training the LLMs from scratch, which is impractical for cutting-edge LLMs due to their prohibitive training costs and black-box nature. The recent RePlug method (Shi et al., 2023b) offers a solution by refining the retriever for black-box LLMs. RePlug utilizes language modeling scores of the answers as a proxy signal to train the dense retriever. However, such supervision for retriever training is indirect and may not be discriminative enough, especially when the questions could be directly answered through the parametric knowledge of the LLM. Therefore, effectively adapting retrievers for black-box LLMs remains an unsolved challenge.
To enhance the retrieval model’s performance, we present our approach, ARL21, which leverages guidance from LLMs through self-guided adaptive relevance labeling. Unlike existing methods that rely on indirect supervision via attention or answerbased language modeling scores, ARL2 leverages
1Short for Aligning Retrievers with Large Language Models via Self-guided Adaptive Relevance Labeling.
3708
the LLMs’ capabilities to directly assess document relevance, results in the curation of high-quality relevance labels to train better retrievers.
The advantages of using LLM-annotated relevance labels for retriever training are threefold. Firstly, ARL2 can effectively distinguish truly useful documents from similar but irrelevant ones, providing valuable positives and hard negatives for training. Secondly, it enables the creation of diverse training data beyond a single target dataset, surpassing the limitations of methods like RePlug. Thirdly, ARL2 can reversely generate diverse questions from unlabeled documents, enhancing data diversity and facilitating effective generalization under challenging few-shot or zero-shot scenarios.
To reduce the cost of data curation due to frequent LLM calls for relevance annotation, we propose an adaptive self-training strategy. This strategy empowers the retriever to identify and label confident and well-trained data points, reducing the reliance on costly LLM interactions. Furthermore, we introduce a cluster-driven prompt demonstration metric to ensure the diversity and high quality of the constructed data. This enables learning a strong retriever from a smaller amount of highquality and diverse annotated data.
Our experiments encompass both open-domain QA datasets (NQ and TQA) and a specific-domain QA dataset (MMLU). The results demonstrate that our framework significantly enhances the perfor-
mance of both the retriever and RAG-based question answering, achieving an accuracy improvement of 5.4% on NQ and 4.6% on MMLU. Moreover, with the diverse curated data and self-training strategy, our method exhibits strong transferability to specific domains with limited training data and delivers promising results even in the challenging zero-shot generalization setting.
In summary, our contributions are as follows: (1) We propose ARL2, a retrieval augmentation framework that effectively aligns retrieval models with black-box LLMs. ARL2 leverages the LLM as a labeler to assign relevance scores with robust LLM self-guided supervision. (2) We incorporate a cluster-driven prompt demonstration metric to ensure the generation of high-quality data. Additionally, we explore a self-training strategy for the retriever to reduce the computational cost of LLM calls. (3) Extensive experiments demonstrate that our retrieval augmentation framework not only improves the performance of LLMs across various question-answering tasks but also exhibits strong transfer and zero-shot generalization capabilities.

heading: 2 Related Work
text: Dense Retrieval. Earlier research has explored various ways to learn representations for text retrieval (Deerwester et al., 1990; Huang et al., 2013; Gillick et al., 2018). With the rise of pre-trained language models, several works have presented the
BERT-based dual-encoder as dense retrievers (Lee et al., 2019; Karpukhin et al., 2020a; Xiong et al., 2021). They typically employ encoders to independently encode queries and documents into a dense space, calculating the similarity via vector dotproduct or cosine similarity. To further enhance performance of dense retrieval models, one line of approaches focuses on developing retrieval-oriented pretraining techniques (Izacard et al., 2022b; Gao and Callan, 2021, 2022; Yu et al., 2022; Xiao et al., 2022; Lin et al., 2023a), and another line of approaches focus on improving the negative contrast loss (Ren et al., 2021; Zhang et al., 2022). Additionally, some models utilize LLM-generated queries to generate synthetic examples for improving retrieval (Ma et al., 2021; Dai et al., 2023), but these dense retrievers are trained separately from LLM and may not always align well with the LLM, potentially resulting in sub-optimal performance when directly applied to target tasks (Lin et al., 2023b).
Retrieval-Augmented LLMs. RAG have been widely used for language modeling (Borgeaud et al., 2022; Ram et al., 2023), question answering (Lewis et al., 2020; Izacard et al., 2022b; Shi et al., 2023b), and domain adaptation (Xu et al., 2023a,b; Shi et al., 2023c). To align retrievers with LLMs, most RAG methods integrate a pre-trained retriever with a generator and subsequently undergo an end-to-end fine-tuning process to effectively capture knowledge (Lewis et al., 2020). Among them, Atlas (Izacard et al., 2022b) leverages retrieved documents as latent variables and fine-tunes retrieval models with four designed loss. AAR (Yu et al., 2023c) identifies the LLM’s preferred documents through FiD cross-attention scores (Izacard and Grave, 2021), and fine-tuning the retriever with hard negative sampling. However, these methods are inapplicable to black-box LLM as they require accessing LLM parameters. The only exception is RePlug (Shi et al., 2023b), which conducts supervised training by evaluating the KL divergence between the probability distributions of the retrieved documents and LLM’s likelihood.

heading: 3 Methodology
text: In ARL2, we employ LLMs to explicitly label relevance scores between questions and evidence, thereby generating relevance supervision for training an LLM-aligned retriever. ARL2 addresses two key challenges: (1) How can we effectively utilize the LLM to construct a diverse and high-quality
training set of relevance labels? (Section 3.1) and (2) How can we train the retriever using the provided relevance supervision and further leverage the retriever to inform adaptive LLM annotation? An overview of our proposed ARL2 method is presented in Figure 1.

heading: 3.1 Data Construction
text: To collect labeled data for retriever learning, it is crucial to go beyond query-document relevance as in standard information retrieval (Lee et al., 2019). In fact, the question q in RAG applications is often under-specified and requires deeper language understanding. Motivated by this, we leverage LLMs to provide direct supervision signals on the usefulness for each piece of evidence for the question.
Specifically, we create training tuples denoted as T = (qi, di, ei, si)|T |i=1, where the evidence e is a text segment extracted from the document d, and the variable s represents the level of support for the question q based on the evidence e. The relevance score s can take on three values: 0 for “no support”, 0.5 for “partial support”, and 1 for “full support”.
We construct the corpus D by compiling various corpora, such as WikiPedia (Vrandečić and Krötzsch, 2014) and MS MARCO (Bajaj et al., 2016). For each document d in D, we generate a training tuple through a three-step process: question generation, evidence identification, and evidence scoring. This procedure yields a dataset of 100,000 annotated instances, denoted as Tg. Additionally, we curate 140,000 data instances Tb from QA benchmarks. The combination of these two sets forms the complete dataset T .

heading: 3.1.1 Question Generation
text: To avoid manually generating questions from a vast amount of documents, we employ ChatGPT (gpt-3.5-turbo-0613) for question generation to generate pairs in the format of (q, e) from documents in the corpus d ∈ D. This process involves providing the LLM reader with a specific prompt, namely, “Given only the information below, following the examples, ask a factual question that we can answer according to the given passage”, along with demonstrations to steer in-context learning. Diverse Generation Strategy. The quality of generated questions heavily relies on the selected document and the provided question examples. Often, the generated questions follow similar patterns as the examples given. Here, the question pattern refers to the sentence structure of the questions,
such as special questions, yes-no questions, and declarative sentences. To enhance the quality of the constructed data, we employ a diverse selection strategy. First, we select relevant questions qr from Tb that share the same or a similar domain with the target document. Second, we cluster the questions in Tb based on their patterns and opt for multiple question patterns from different clusters to generate diverse questions. To facilitate diverse and high-quality question generation, we mask the entity mentions in the questions to focus on their core structure. Each masked question is then mapped into a sentence embedding and clustered using ISODATA (Ball et al., 1965), a variation of K-means. This makes the generated questions not only diverse but also of high quality.

heading: 3.1.2 Support Evidence Annotation
text: Evidence Identification. For each data point (qi, di, ei) in Tb, we assign a support level label s to indicate the relevance of the evidence ei to the question qi. If (qi, di, ei) is directly obtained from human annotators, we set s to “full support”. Otherwise, we use ChatGPT as an annotator to obtain the support level label. Specifically, we provide ChatGPT with the question qi, the document di, and an instruction to extract the supporting evidence from the document. ChatGPT then returns the extracted evidence and its relevance score to the question. Evidence Scoring. In addition to the positive sam-
ples with “full support” labels, we also create negative samples for training the retrieval model. For each positive sample (qi, di, ei), we construct a challenging negative set Ni by selecting evidence segments from the same document di or from other documents that are content- or domain-similar to di. We embed each evidence segment in Ni using SimCSE (Gao et al., 2021), a sentence embedding model. Then, we identify the top-k most semantically similar evidence segments to ei based on their cosine similarity scores. Finally, we ask ChatGPT to label the relevance of these top-k evidence segments to the question qi. We discard the evidence segments labeled as “full support” and retain the ones labeled as “partial support” or “no support” as negative samples.

heading: 3.2 Retrieval Model Learning
text: In ARL2, we train a dense retriever from the above instances of <question, evidence, relevance score>. To enhance the learning of the retriever, we design pairwise and list-wise losses that incorporate hard negative sampling. Furthermore, to reduce the cost associated with ChatGPT annotation, we propose a self-training strategy that enhances efficiency.

heading: 3.2.1 Dense Retriever
text: Given a query q and an evidence corpus D = {d1, d2, . . . , d|D|}, the goal of the dense retriever is to first map all the documents d ∈ D in a dense vector to build an index for retrieval, then retrieve the top-k most relevant documents via efficient vector similarity metrics.
We leverage the dual-encoder structure (Lee et al., 2019; Karpukhin et al., 2020b; Lin et al., 2023a) to embed query and documents using text encoders initialized from pretrained language models. Specifically, the query encoder EQ(·) and document encoder ED(·) map queries and documents d ∈ D to low-dimensional real-valued vectors:
sim(q, d) = cos (EQ(q), ED(d)) . (1)
For efficient retrieval, we pre-compute the embedding of each document in D and construct a FAISS index (Johnson et al., 2019).

heading: 3.2.2 Learning Objective for Dense Retreivers
text: To train the retriever, we employ a ranking loss. For each query qi, we obtain the positive candidate e+ along with a list of negative evidence candidates Ni = {e1, e2, ...}. For each negative sample ej ∈ Ni, we obtain its corresponding predicted relevance
score ŝij = sim(qi, ej) with the dual encoder and labeled relevance score sij via LLM prompting (Figure 2). In specific, we optimize the retriever by
L = Llist + Lpair,
where Llist indicates a list-wise loss that discriminates between the positive and all listed negative evidence, and Lpair indicates a pairwise loss which focus on pairwise comparison between both (“full support” ,“partial support”) and (“partial support”,“not support”). List-wise Contrastive Loss. We utilize an InfoNCE loss which encourages positive instances to have high scores and negative instances to have low scores, which is defined as:
Llist (si, ŝi) = − exp
( ŝ+i /τ )
exp ( ŝ+i /τ ) + ∑|Ni| j=1 exp (ŝij/τ)
where ŝ+i is the score for positive instance which is labeled as “full support”, and τ is a temperature parameter. Pairwise Logistic Loss. To better capturing the fine-grained relevance information beyond binary relevance labels, we further leverage a pairwise loss to deal with the “partial support”, which is defined as follow,
Lpair (si, ŝi) = |Ni|∑
j=1
|Ni|∑
j′=1
Isij>sij′ log ( 1 + eŝij′−ŝij )
The aim of employing pairwise logistic loss is to ensure that a partially supported document can achieve a higher score than a fully negative one, while still scoring lower than a fully supported positive document.
Negative Sampling. Another important aspect of the above learning objective is how to mine negative examples Ni for each query qi. Here we propose a multi-step bootstrapped strategy to gradually provide “harder” negative examples to effectively train the retriever. Initially, we kickstart the retriever training using in-batch negative samples as the warmup (Gillick et al., 2018; Lee et al., 2019). Then, we choose the “partial support” document as hard negative for both loss for further model training. This advanced negative sampling strategy significantly improves the retriever’s performance compared to using randomly selected or BM25 selected negative samples (Karpukhin et al., 2020b).

heading: 3.2.3 Adaptive Relevance Labeling
text: Although data collection can proceed without human annotations, utilizing ChatGPT series APIs comes with associated costs. To mitigate these expenses, we propose an adaptive strategy wherein we initially label only a subset of support evidence training data Ts first. After the warm-up epochs trained by Ts, given a (qi,d) pair without annotation, we segment document d into text chunks d = {ei,1, ..., ei,n} and enable the retriever to select the support evidence eij with highest relevance score as
s(qi) = max j∈{1,2,...,n} sim(qi, ei,j).
Such a confidence score s(qi) reflects the model’s confidence on question qi. Rather than evaluating confidence for each question individually, we first cluster questions (following the same pipeline as in Sec. 3.1.1) and calculate the confidence score for each cluster C1, C2, ..Cm, which denotes as
s(Ci) = ∑
qt∈Ci s(qt)/|Ci|.
When a cluster exhibits a high model confidence score, we depend on the retriever’s predictions and integrate all confident predictions within the cluster as supplementary training data. Specifically, we fine-tune the retriever using both the original training data and the newly generated training data in the subsequent epoch. Conversely, if a cluster’s confidence score is low, we resort to the data construction process outlined in Sec. 3.1, which utilizes ChatGPT to create more relevance labels.

heading: 3.3 Inference
text: Formally, the LLM conditions on both the input question q and the support evidence Dq to generate a textual output y as the answer. To augment the support evidence, a simple way is to input the evidence in Dq from the highest relevant to the least relevant. However, the LLM is shown to be not robustly accessing or using information in long input contexts and may lose information in the middle (Liu et al., 2023). Therefore, we reorder the top-k documents, placing the most relevant document at either the beginning or the end of its input context. Concretely, we cut the Dq into three subsets according to the relevance score and put d1 to dj at the beginning, dj+1 to d2j at the end, and the rest at the middle, showing as following
R1 = d1 ◦ ... ◦ dj ◦ d2j+1 ◦ ... ◦ dk ◦ d2j ◦ ... ◦ dj+1
where the ◦ denotes the concatenation of two sequences. To ensure robustness, we further rearrange the order within each subset for N times to obtain permutations R = {R1, . . . , Rn}, and then ensemble the likelihood provided by the LLM for each Ri to calculate the final answer score as
p(y|q,Dq) = N∑
i=1
P (y|q ◦Ri).

heading: 4 Experiments

heading: 4.1 Experimental Setting
text: Datasets. We evaluate the effectiveness of our framework through various open domain QA datasets, encompassing both general tasks including Natural Questions (NQ) (Kwiatkowski et al., 2019), TriviaQA (TQA) (Joshi et al., 2017) as well as domain-specific tasks like MMLU (Hendrycks et al., 2021). NQ comprises natural questions extracted from real Google search, while TQA emphasizes trivia questions. MMLU is a multiple-choice QA benchmark which can be categorized into humanities, STEM, social sciences, and others. For the document corpus, we follow DPR (Karpukhin et al., 2020a), and construct a corpus of 300,000 QA pairs in total, which consists of 8.8 million passages from MS MARCO (Bajaj et al., 2016) and about 21 million passages from Wiki dump (Vrandečić and Krötzsch, 2014). The size of each dataset is detailed in Table 1. Baselines. We compare our methods with strong baselines for open-domain question-answering tasks, which can be divided into: traditional joint training approaches and LLM-based approaches. Specifically, traditional joint training approaches encompass RETRO (Borgeaud et al., 2022), UnifiedQA (Khashabi et al., 2020), and Atlas (Izacard et al., 2022b). The LLM-based approach involves prompting the LLM to generate answers to questions. Representative LLM examples in our evaluation include Chinchilla (Hoffmann et al., 2022), PaLM (Anil et al., 2023), ChatGPT (OpenAI, 2023), Codex (Chen et al., 2021), GenRead (Yu et al., 2023a). To establish stronger baselines, besides raw LLMs, we compare our methods with retrieval augment methods which incorporating welltrained retrievers such as Contriever (Izacard et al., 2022a), Replug (Shi et al., 2023b), both in a fewshot training setting, and also we evaluate the fully supervised DPR (Karpukhin et al., 2020b). Evaluation Metrics. We evaluate the Recall@Topk (k = 10, 20) for retriever performance, measuring
whether the answer match a text span within the Top-k retrieved passages. For the overall precision, we consider accuracy (Acc.), verifying whether the answer generated by the RALM exactly matches the ground true answer in the dataset. Settings. Based on DPR, we trained ARL2 with generated training instances based on the above corpus along with the benchmark dataset. Additionally, we evaluate different versions of ARL2. ARL2 (few-shot) is a few-shot variant which trained on contriever and solely on generated instances along with few-shot benchmark training data. Furthermore, we examine ARL2 (w/ re-ranker), an enhanced version that utilizes a generation-based reranker to improve retriever performance. Specifically, we employ the retriever to fetch the top 50 passages for each question and segment each document into text chunks for re-ranking, which ensuring to be within 50 words or 3 sentences. The re-ranker is trained with the same loss and training instances as the retriever. We evaluate all versions of our framework on ChatGPT with 20-shots.

heading: 4.2 Overall Result
text: The overall results are shown in Table 2,with bold indicating the best and underline indicating the second-best performances. Our retriever can enhance LLMs: Both “ARL2” and “ARL2 (w/ re-ranker)” outperform raw ChatGPT demonstrating that the retrieved evidence can correct the factual errors within ChatGPT’s inparameter knowledge. Especially, we exhibit a remarkable 6% gain on MMLU, as MMLU involves extensive knowledge in a specific domain and certain numerical statistics that are often messed in ChatGPT’s in-parameters. Our retrieved evidence contains the correct statistics, which can assist ChatGPT in correcting its answers. ARL2 surpasses other retrieval augmentation methods, including strong baseline RePlug and other traditional retrievers. These outcomes suggest that our model adapts more effectively to LLM because it’s trained on LLM-labeled data, ensuring that the retrieved evidence aligns better with
LLM requirements. Additionally, we compare our model with some joint training baselines (RETRO, Atlas and UnifiedQA), owing to the strong capabilities of ChatGPT, augmenting black-box LLM with retrieved evidence effectively reduces the issue of hallucinations and surpasses joint training of medium-size PLM. Our re-ranker significantly improves retrieval performance, as indicated in the table. “ARL2 (w/ re-ranker)” outperforms pure retriever baselines. The re-ranker divides passages into multiple pieces of evidence, enabling a fine-grained ranking with our adaptive labeling strategy. Because the evidence is shorter than the entire passage and exhibits higher recall with a stronger base model, the re-ranker provides a more concise and accurate augmentation for the language model. This is particularly advantageous due to input length limitations imposed by the language model, resulting in a much better performance compared to “ARL2”.

heading: 4.3 Generalization and Transfer Ability
text: Few-shot Transfer Performance. We first evaluate the few-shot transfer ability of our retriever. In our training process, we solely pre-trained the retriever using data derived from or constructed
from the MS MARCO datasets which only contain document corpus and questions, following Contriever. Subsequently, we employed few-shot questions (setting as 20 in our experiment) from MMLU as in-context learning examples to generate additional training data exclusively based on the document corpus. As the result shown in the left two columns of Table 3, our model has surpassed both the raw LLM and other baseline retrieval methods, indicating its superior transfer capabilities. As our model fully utilizes the few-shot examples, generating training data patterns similar to those in the MMLU dataset, our retriever is familiar with the setting in MMLU even with a few data.
Zero-shot Generalization Performance. We evaluate the zero-shot ability by training a retriever solely on the benchmark data in the NQ dataset and the constructed data from the NQ corpus, then directly test the model on TQA dataset. As shown in right column of Table 3, the result demonstrates that our retriever has stronger generalization abilities. Additionally, we provide the retriever’s recall rate to emphasize that our model’s transfer ability isn’t solely attributable to ChatGPT’s robust generalization capabilities, the diverse select strategy has imparted a level of generalization to the retriever itself by maintaining a diverse range of training data across various domains and patterns.

heading: 4.4 Ablation Study
text: As shown in Table 4, we here perform the ablation study to demonstrate the impact of each strategy in construct relevance label and training the retriever.
Impact of Ranking Loss. Our final model leverage both pairwise and list-wise, and we here perform three models with different loss setting, “w/o pairwise” indicates training the retriever without the pairwise loss, “w/o listwise” indicates training the retriever without the list-wise loss. The results show that remove pairwise loss and list-wise loss will drop recall, and leveraging both loss can achieve a better performance, as it both consider multiple random simple negative evidence to warm up but also take consider hard negative evidence through the pairwise to further improve models’ performance. We also evaluate “w/ neg sample” which replace our negative sample strategy with BM25 negatives (Karpukhin et al., 2020b), and the results show the efficient of our strategy by bring harder cases for model training.
Impact of Relevance Label Training Instance. Our labeled data can contribute the retriever’s performance mainly on two aspect, the labeling of partial support evidence and the construction of more training data. So we perform ablation study on these two aspect, where “w/o partial” denotes
removing all partial label, and “w/o label data” denotes removing all annotated data. The results show that both these removing drop accuracy, but “w/o label data” drop rapidly, which indicates that more data is more important than detailed training data.
Impact of Less Training Data. Considering the costly nature of API calls for data generation, we evaluate model performance with a smaller subset as training data. As shown in Figure 3, the result illustrates that increased training data leads to enhanced performance, with optimal results achieved when all generated data are utilized. However, the rate of improvement declines with the increasing of training data, indicating that by selectively labeling diverse data, costs can be reduced while maintaining comparable performance. Compare to the diverse self-train strategy, we also show the performance of randomly selection and training solely based on it. As shown, the self-train method can save the cost and achieve better result within same less data, which is more efficient.
Impact of Inference Reformulation. For inference, analysis the impact of two input reformulation strategies, “w/o ensemble” indicates the model directly takes the result from middle-rank input, “w/o middle-rank” indicates the model take a simple positive rank input. And the result shows that both these two strategy can benefit LLM’s performance. The accuracy does not drop much indicates that although model may lost information in middle, LLM can still obtain some external factual information from the input augment data.

heading: 5 Conclusion
text: We introduce ARL2, a retrieval-augmentation framework that harnesses the capabilities of LLMs as annotators for retriever learning. Unlike conventional approaches that face misalignment due to separate training processes and the inherent complexity of LLMs, our framework dynamically leverages LLMs to annotate and assess relevant evidence. This enables the retriever to benefit from robust LLM supervision. Additionally, we incorporate a self-training strategy to mitigate the cost associated with API calls. Through extensive experimentation, we demonstrate the effectiveness of ARL2, which enhances accuracy in open-domain QA tasks, exhibits robust transfer learning capabilities, and showcases strong zero-shot generalization abilities.

heading: Acknowledgements
text: We would like to thank reviewers from the ACL Rolling Review for the helpful feedback. This work was supported in part by NSF IIS-2008334 and CAREER IIS-2144338.
Limitations
In this research, annotating relevance labels can be expensive due to the extensive use of ChatGPT APIs. Our future work will further explore strategies to generate diverse, high-quality data to reduce these costs. Additionally, we aim to expand the curated relevance data to cover more specific domains like biomedical and life sciences. Correspondingly, we will evaluate the method’s performance on tasks from such domains to assess its generalizability.

heading: A Appendix
text: A.1 Implementation Details To enhance the efficiency of the training process, we establish a FAISS index for rapid similarity searches. To train the model, we employ the AdamW optimizer (Loshchilov and Hutter, 2017) with a learning rate of 2e-5, a batch size of 256, and a warm-up ratio of 0.1 during training. Following (Shi et al., 2023b), document embeddings are refreshed every 5k steps. In the case of few-shot learning, we adhere to the setup in contriever (Izacard et al., 2022a), utilizing a momentum value of 0.9995 and a temperature of 0.05, and a learning rate of 5e-5, a batch size of 512. The dense retriever is initialized with BERT-base-uncased model (Devlin et al., 2019).
A.2 Diverse Generation Details We leverage BERT (Li et al., 2023) to embed the questions in the pool. In order to ensure the diversity of demonstrations, we employ the classic K-Means algorithm to cluster questions based on their embeddings. The number of clusters is set to 6, and the structure of questions can be YesNo, What/When, Which, Numeric, Location, Person. We select questions by randomly choosing one question from each group. Notably, we mask entity mentions in each question to allow the clustering algorithm concentrate on the sentence structure information rather than specific instances.

heading: Future Work
text: Our future work will further explore strategies to generate diverse, high-quality data to reduce these costs. Additionally, we aim to expand the curated relevance data to cover more specific domains like biomedical and life sciences. Correspondingly, we will evaluate the method’s performance on tasks from such domains to assess its generalizability