Grounding by Trying: LLMs with Reinforcement Learning-Enhanced Retrieval

## Abstract

Abstract The hallucinations of large language models (LLMs) are increasingly mitigated by allowing LLMs to search for information and to ground their answers in real sources. Unfortunately, LLMs often struggle with posing the right search queries, especially when dealing with complex or otherwise indirect topics. Observing that LLMs can learn to search for relevant facts by trying different queries and learning to up-weight queries that successfully produce relevant results, we introduce Le arning to Re trieve by T rying (LeReT), a reinforcement learning framework that explores search queries and uses preference-based optimization to improve their quality. LeReT can improve the absolute retrieval accuracy by up to 29% and the downstream generator evaluations by 17%. The simplicity and flexibility of LeReT allows it to be applied to arbitrary off-the-shelf retrievers and makes it a promising technique for improving general LLM pipelines. Project website: http://sherylhsu.com/LeReT/ .

## 1 Introduction

Despite tremendous progress, large language models (LLMs) still often hallucinate, motivating significant interest in grounding LLM answers in verified sources (Guu et al., ; Komeili et al., ; PerplexityAI, ; Google, ; OpenAI, ). Unfortunately, simply retrieving semantically similar documents to the user question, as is prevalent in retrieval-augmented generation (RAG; Lewis et al. ) pipelines, tends to fail for complex information needs not answered directly by any individual document. To tackle this, multi-hop retrieval pipelines gather information incrementally over multiple steps of search. For example, if a user asks What is a good dinner place driving from the Bay Area to Lake Tahoe on Friday night to avoid traffic?, a grounded system might need to learn about towns en route Lake Tahoe from the Bay Area, followed by traffic forecast on I-80 and finally, restaurants in Auburn (and other towns).

However, doing this successfully is hard as off-the-shelf LLM performance is often unsatisfactory, and producing supervision for the best search queries to generate in a sequence of “hops” is non-trivial and expensive. Recent work tackles this via prompt optimization and rejection fine-tuning given a downstream signal. For example, Khattab et al. () “bootstrap” trajectories of reasoning and search queries and collect trajectories that lead to a high downstream answer accuracy, using them either to search for effective few-shot prompting examples or to finetune the LLM responsible for query generation. We observe that the problem of teaching a LLM to generate effective search queries is inherently a reinforcement learning (RL) problem and ask can RL improve the grounding of answers generated by LLMs when wielding open-ended tools like search engines?

If LLMs can observe the retrieved documents for different search queries, and receive rewards for finding relevant documents, they could learn which queries lead to better outcomes. Such learning from trial-and-error naturally lends itself to RL formalism, going beyond imitation-based methods in prior works. Indeed, we find that naïve sampling from LLMs with high temperature and using the observed data for RL is not effective. Instead, our proposed framework, Learning to Retrieve by Trying, or LeReT, induces diverse search queries for each question by diversifying the few-shot examples in the prompts of the system. After this diversified sampling of search queries and the resulting retrieval, LeReT applies context distillation (Snell et al., ) followed by optimizing the query-generating LLM using preference-based RL. We use identity policy optimization (IPO; Azar et al. ; Rafailov et al. ), though other RL algorithms can be substituted.

Our main contribution is LeReT, a framework for improving grounding of LLM answers by leveraging retrieval annotations to improve multi-hop retrieval accuracy. On two question-answering datasets, LeReT considerably outperforms prior methods like few-shot prompting and supervised fine-tuning in both retrieval quality and downstream generation quality, with stronger generators like GPT-4 benefiting more from the improvements in retrieval. We experiment with an iterative version of LeReT and find that its performance improves over iterations. Our analysis reveals that prompt-driven diverse sampling is critical for LeReT to be effective, and we also analyze different ways to generate rewards for retrievals. Finally, our experiments find that LeReT can be used across retrievers, and thus, provides a simple and general framework for improving retrieval. While we focus on retrieval for grounding LLM answers in this work, the core method behind LeReT can be straightforwardly extended to other agentic pipelines in which LLMs control a blackbox tool, so long as a reward can be formulated on its outputs.

Figure: Figure 1: LeReT significantly improves retrieval and generation. LeReT provides a reinforcement learning based framework for improving grounding and performance of LLM generated answers by improving the retrieval of relevant factual data.
Refer to caption: x1.png

## 2 Related Work

Retrieval-Augmented Generation (RAG). Over the past few years, interest has been growing in conditioning LLM outputs on retrieved information (Chen et al., ; Lee et al., ; Guu et al., ; Lewis et al., ; Lazaridou et al., ; Asai et al., ). This strategy seeks to make LLM systems more efficient, updatable, and transparent by decoupling the system’s knowledge from the model parameters. This makes it easy to update the knowledge corpus and also makes it possible to inspect the sources relied upon when LLMs produce factual statements.

Multi-Hop Retrieval. The standard RAG formulation is best suited for “simple” questions, where a direct search can find all the information required for producing responses. Beyond these, benchmarks such as HotPotQA (Yang et al., ), MuSiQue (Trivedi et al., ), and HoVer (Jiang et al., ) assess systems on gathering and synthesizing information from several independent documents within a massive corpus like Wikipedia. To tackle retrieval in this setting, early systems like MDR () and Baleen (Khattab et al., ) introduced bespoke strategies for fine-tuning the retrieval models that produce representations of queries and documents, adapting them directly for compositional search queries. Unfortunately, fine-tuning the retriever representations is a data hungry approach that is also challenging to scale to massive corpora like the Web, as re-training the retriever often requires re-indexing the corpus. Increasingly, research in this space (Trivedi et al., ),
(Yao et al., ; Khattab et al., ; Press et al., )
relies on off-the-shelf retrievers such as the Wikipedia API and focuses on improving LLMs’ ability to to generate effective queries.

Optimizing LLM Programs & Agents. Recent work tackles this by employing prompt optimization and rejection fine-tuning using a downstream signal. For example, in Khattab et al. (), the authors “bootstrap” trajectories of reasoning and search queries and use the trajectories that lead to a high downstream answer accuracy as candidate examples. The trajectories are then used either to search for effective few-shot prompting examples or to finetune the LLM responsible for query generation. This approach was extended in Opsahl-Ong et al. () and Soylu et al. () in which the authors also explore using these trajectories to search for free-form instructions for prompting or to nest forms of rejection fine-tuning and prompt optimization, respectively. A key difference in our work from this line of research is that we assume access to direct-supervision rewards after every retrieval step in the pipeline, rather than only for the final response, and find that this enables much more powerful learning in practice. Beyond LLM programs, similar techniques can be used for optimizing agent behavior. For example, in Song et al. (), the authors improve LLM agents by collecting failure and success trajectories and training the LLM using preference optimization. Our work finds that the quality of exploration data sampled from LLMs is critical to the success of RL in agentic pipelines, and introduces a prompt-based diversification strategy that samples diverse and high-quality exploration data (discussed in Section 4.1, analysis in Section 5.4).

## 3 Preliminaries

Figure: Figure 2: An overview of the standard multi-hop retrieval pipeline we study in this work. A user asks a question to the system. In each hop, the LLM generates search queries for the retriever and receives a collection of documents. The overall set of retrieved documents and the user question are then given to a downstream LLM for grounded answer generation.
Refer to caption: extracted/5967313/images/retriever_pipeline.jpg

Multi-Hop Retrieval Setup. An overview of retrieval is shown in Figure 2. We assume access to a retriever that maps a search query $q$ to a set of $N$ most similar documents ${D=\{d_{i}\}_{i=1}^{N}}$, where $d_{i}$ denotes an individual document. A user asks a question $u$, a LLM $\pi_{r}$ generates a query $q_{1}$ for the retriever, which results in an ordered set of document $D_{1}$. In the next hop, the LLM $\pi_{r}$ takes $u$ and $D_{1}$ as input and outputs query $q_{2}$. This repeats for $H$ hops. The final ordered set of retrieved documents $D_{R}=D_{1}\cup D_{2}\cup\ldots D_{H}$ is given as input to the LLM generator $\pi_{g}$ along with the question $u$, which generates the final answer for the user query. In this work, we restrict ourselves to fine-tuning the LLM $\pi_{r}$ and treat the retriever and LLM generator $\pi_{g}$ as blackbox models.

Language Models and Reinforcement Learning. Reinforcement learning has become the de facto tool for aligning large language models and has inspired considerable work at the intersection of language models and RL (Stiennon et al., ; Ouyang et al., ; Zhao et al., ; Rafailov et al., ). We briefly review direct alignment methods (Rafailov et al., ). Given a dataset of preferences $\mathcal{D}_{p}=\{x^{i},y^{i}_{w},y^{i}_{l}\}$, where $x^{i}$ denotes the dialogue history, $y^{i}_{w}$ denotes the preferred response and $y^{i}_{l}$ denotes the dispreferred response. Bradley-Terry (Bradley & Terry, ) offers a model that connects choice to an implicit goodness score, useful for learning a reward model $r_{\phi}$:

$$ $\mathcal{L}_{\textrm{BT}}=-\mathbb{E}_{(x,y_{w},y_{l})\sim\mathcal{D}_{p}} \left[\log p_{\phi}(y_{w}\succ y_{l})\right]=-\mathbb{E}_{(x,y_{w},y_{l})\sim \mathcal{D}_{p}}\left[\log\sigma\left(r_{\phi}(x,y_{w})-r_{\phi}(x,y_{l}) \right)\right],$ (1) $$

where $\sigma$ denotes the sigmoid function and $p_{\phi}(y_{w}\succ y_{l})$ denotes the probability of $y_{w}$ being preferred over $y_{l}$. Typically a LLM $\pi$ is trained to maximize this learned reward model using RL as described by $\max_{\pi}\mathbb{E}_{y\sim\pi(\cdot|x)}\left[r_{\phi}(x,y)-\beta\textrm{KL}(
\pi\mid\mid\pi_{\textrm{ref}})\right]$, where $\pi_{\textrm{ref}}$ denotes a fixed reference policy. However, Rafailov et al. () shows that parameterizing $r_{\phi}(x,y)=\beta\log\left(\pi_{\phi}(y\mid x)/\pi_{\textrm{ref}}(y\mid x)\right)$ and optimizing Eq 1 implicity optimizes the RLHF objective exactly, removing the need for a separately parameterized reward model or an explicit RL training loop. However, Azar et al. () and Rafailov et al. () have found that optimizing a DPO parameterized reward uing Eq 1 can lead to overoptimization, and suggest optimizing the following objective:

$$ $\mathcal{L}_{\textrm{IPO}}=\mathbb{E}_{(x,y_{w},y_{l})\sim\mathcal{D}_{p}} \left[\left(\tilde{r}_{\phi}(x,y_{w})-\tilde{r}_{\phi}(x,y_{l})-0.5\tau^{-1} \right)^{2}\right]$ (2) $$

where $\tau$ is a hyperparameter controlling the target margin between the implicit rewards for $y_{w}$ and $y_{l}$, and $\tilde{r}_{\phi}(x,y)=\log\left(\pi_{\phi}(y\mid x)/\pi_{\textrm{ref}}(y\mid x
)\right)$. Minimizing the objective in Eq 2 leads to identity policy optimization (IPO; Azar et al. ).

## 4 LeReT: Learning to Retrieve by Trying

We introduce Learning to Retrieve by Trying, or LeReT, a novel framework for improving the grounding of LLM generations by training the search query LLM $\pi_{r}$ using preference optimization. In hop $i$, we sample a query $q_{i}$ from the LLM based on the user question and documents seen in hops $<i$, and observe a reward signal for the retrieval quality. Both sampling from the LLM and retrieval make it hard to backpropagate directly from the reward signal, making RL a more suitable optimization framework for this setting. We first discuss how to generate a dataset of queries and retrieved documents that is suitable for RL optimization in Section 4.1. We then discuss how to convert the reward-annotated dataset into a dataset of preferred and dispreferred queries and use that dataset to optimize $\pi_{r}$ with IPO in Section 4.2. We also briefly discuss an iterative version of LeReT that alternates between sampling and optimization. Finally, we combine the elements and give a practical overview in Section 4.3.

### 4.1 Prompt Driven Diverse Query Generation

Given a dataset of questions, we want to “try” a set of search queries and observe the retrieved documents. What queries would be good to observe the retrieved documents for? This roughly corresponds to the exploration problem in RL. As our experiments later in Section 5.4 also indicate, a good distribution of queries would result in diverse outcomes (for better exploration), but it is important that some queries produce high quality retrievals.
To sample such diverse and effective queries, LeReT moves beyond high-temperature sampling and uses a diverse set of examples to few-shot prompt the LLM $\pi_{r}$. We use DSPy (Khattab et al., ; )’s prompt optimizers, specifically a simple BootstrapFewShotWithRandomSearch (BFRS), to self-generate a number of independently optimized few-shot, chain-of-thought prompts $\mathcal{P}=\{p_{1},\dots,p_{P}\}$ for LLM $\pi_{r}$. The independently optimized prompts would naturally lead to diverse samples from $\pi_{r}$, and DSPy’s optimization ensures that the prompts are still resulting in relevant retrievals. Note that we can reuse the same set of prompts across all questions throughout the dataset.

For a hop $h$, LeReT does the following: For every question $u\in\mathcal{U}$, LeReT samples search queries conditioned on each of the prompts $p\in\mathcal{P}$, resulting in a set of search queries ${Q_{h}=\{\pi_{r}(\cdot\mid p_{i},u,C_{h-1}))\mid p_{i}\in\mathcal{P}\}}$, where $C_{h-1}$ denotes the context from previous hops. For every query $q_{i}\in Q_{h}$, we retrieve a set of documents denoted $C_{hi}$ and compute the reward corresponding to each query by evaluating the retrieved documents, that is $r_{\textrm{ret}}(u,C_{h-1},q_{i})=\mathbb{R}(C_{hi})$ (more on retrieval reward $\mathbb{R}$ in Section 4.3). The final dataset for this hop consists of ${\mathcal{D}_{h}=\{\left(u,C_{h-1},q_{i},r(u,C_{h-1},q_{i})\right)\mid u\in
\mathcal{U},q_{i}\in Q_{h}\}}$, where every entry consists of the user question, the context from the previous hop, the sampled query, and the reward computed by running the retriever. Though the prompts we generate are used to sample diverse high quality search queries at training time, we leverage context distillation to remove the need for optimized prompting at test-time.

When training in a multi-hop setting like this, we must select which contexts to use for the next hop. Naïvely generating queries for every possible context leads to an exponentially growing dataset with respect to the number of hops, which becomes computationally infeasible quickly. At the end of hop $h$, we have $P$ different contexts $C_{hi}$ for a given question. LeReT randomly selects one of the $P$ contexts to use for the next hop, creating $C_{h}$. To do this, we first filter out contexts that have achieved the optimal reward (assumed to be 1), as no more relevant documents can be retrieved. For the remaining contexts, we weigh each context by the reward and sample one of them. This biases the data towards trajectories that achieve higher reward, while still containing trajectories where the model can recover from poor retrieval in earlier hops. The final training dataset is simply the union of the dataset from each hop, that is $\mathcal{D}_{\textrm{tr}}=\mathcal{D}_{1}\cup\ldots\mathcal{D}_{H}$. The pseudocode for dataset sampling is given in Algorithm 1.

Figure: Figure 3: Overview of prompt driven diverse sampling and data generation. LeReT induces diverse but effective search queries by bootstrapping several few-shot prompts for query generation and uses the retrieval reward to collect preferred and dispreferred queries for each question’s hop.
Refer to caption: extracted/5967313/images/main_figure.jpg

### 4.2 Model Optimization

Given the training dataset $\mathcal{D}_{\textrm{tr}}$, we want to update the LLM $\pi_{r}$. First, we make a simplification by optimizing every hop greedily, that is, based on the reward obtained in that hop alone. Ideally, updating $\pi_{r}$ on data in hop $h$ accounts for rewards obtained in all future hops. Retrieving relevant documents in earlier hops is likely always better, and intuitively, retrieving irrelevant documents in earlier hops will rarely lead to better overall retrieval. We verify this assumption empirically: For two sets of retrieved documents, a low reward and high reward set, a low reward retrieval leads to a higher total reward in only 0.026% of the cases (Appendix B.1). Thus, the greedy approach considerably simplifies the optimization, without any evident theoretical or empirical sacrifice.

Given the dataset $\mathcal{D}_{\textrm{tr}}$, we can optimize $\pi_{r}$ using any RL algorithm. In this work, we consider preference-based RL approaches, specifically IPO described in Section 3 because of its simplicity and effectiveness. To optimize $\pi_{r}$ using IPO, we need to transform $\mathcal{D}_{\textrm{tr}}$ into a preference dataset. This can be done straightforwardly by comparing two search queries $q_{i}$ and $q_{j}$ for the same user question and context and choosing the query with higher reward as the preferred response and the other query as the dispreferred response. However, before we can optimize $\pi_{r}$ using IPO, we must account for the fact that the search queries were sampled using few-shot prompting, and at test-time we will not be using the prompt. To do so, we leverage context distillation (Snell et al., ) by fine-tuning on the search queries without the context. We observe in our experiments that this roughly matches the performance of few-shot prompting. After context distillation and converting the training dataset into a preference dataset, we optimize $\pi_{r}$ using IPO.

Iterative-LeReT. Thus far, we have assumed that sampling search queries and model training are done as two separate steps. However, we can alternate between the two steps, leveraging the improvements in previous iterations to sample better data for the next iterations. Iterative-LeReT closely follows iterative-DPO (Xu et al., ). We partition the dataset of user questions $\mathcal{U}$ and run LeReT on each partition, sampling from the model fine-tuned on the previous partitions. Specifically, we have $I$ data partitions $\mathcal{U}_{1},\dots,\mathcal{U}_{I}$. We start with the LLM $\pi_{0}$ and apply LeReT on $\mathcal{U}_{1}$ to obtain the fine-tuned LLM $\pi_{1}$, so we have LeReT ($\pi_{0},\mathcal{U}_{1}$) $\rightarrow\pi_{1}$. We use LeReT on $\mathcal{U}_{2}$, using $\pi_{1}$ to sample the training data and continue fine-tuning from, that is, LeReT ($\pi_{1},\mathcal{U}_{2}$) $\rightarrow\pi_{2}$. We can repeat this for all $I$ partitions until we get the final model $\pi_{I}$. We find that iterative sampling and training can be effective as models may not achieve accurate and relevant retrievals in the initial iterations, and later models may be able to generate better exploration data.

### 4.3 Reward Labeling for Retrieved Documents

In order to construct the required preference datasets, we need a reward signal $\mathbb{R}$ to score the documents retrieved by a search query. How do we compute this reward signal? There are broadly two ways to get such supervision: direct supervision, where a human provides oracle documents to ground the answers in the training dataset or explicitly reviews the relevance of documents retrieved by the search query and indirect supervision, where the supervision comes from evaluations of the downstream generator such as preference feedback on the final answers or some answer verification. The latter is indirect because we do not obtain any explicit supervision for retrieval, but only receive information about how the generator performed after being conditioned on the retrieved documents. We run a short study in Section 8 comparing the two forms of supervision, and find that direct supervision results in better performing models. However, a full study comparing direct and indirect forms of supervision and their trade-offs is beyond the scope of this paper, and potentially requires novel algorithmic considerations. For the majority of the paper, we assume some form of direct supervision, as allowed by commonly used datasets and benchmarks.

Figure: Algorithm 1 Prompt Driven Diverse Sampling + Training

## 5 Experimental Evaluation

We now evaluate how LeReT impacts the quality of retrieval and of downstream generation. We first test LeReT on two multi-hop question answering datasets, finding that LeReT significantly outperforms baselines such as few-shot prompting and supervised fine-tuning. We also find that applying LeReT iteratively leads to further improvement over iterations. We analyze prompt driven diverse sampling in contrast with sampling using high temperature and also discuss different reward functions for the retrieval step. Finally, we evaluate LeReT’s adaptability for various pipelines by testing it against retrievers.

Datasets. We test LeReT on HotpotQA (Yang et al., ) and HoVer (Jiang et al., ). Both datasets are based on a Wikipedia knowledge base and are multi-hop, meaning that models must reason across multiple articles to arrive at the correct answer. The datasets provide both the correct answer and supporting articles. HotpotQA is a question-answering dataset that requires up to 2 hops, while HoVer is a fact verification dataset that requires up to 4 hops. Both datasets are relatively large, allowing us to train on over 10,000 questions.

Evaluation metrics. We measure retrieval performance using recall and average precision. Recall is the number of correctly retrieved documents over the total number of correct documents. Average precision (Eq. 3 in the appendix) takes into account the ordering of the documents, i.e. if the correct 3 documents are ranked as the last 3 out of 6 the score will be lower. For generation, we measure both exact match on the entire answer and F1 at the word level.

Baselines. For our baselines, we compare against using the base (general-purpose, instruction-tuned) model to generate queries and also prompting the base model using bootstrapped few shot prompts optimized by DSPy. For the main few shot prompting baseline, we use the few shot prompts used during prompt driven diverse sampling. These prompts are created by optimizing the first hop with DSPy and then using that prompt for all hops. To demonstrate that the gains of LeReT are additive on top of these, we report the maximum achieved few-shot prompt performance achieved by any bootstrapped fewshot prompt $p_{1},\dots,p_{P}$. For some experiments, we also report few-shot all, which is where we use DSPy to optimize over the entire pipeline and bootstrap different examples for each hop. We also report LeReT-CD as a baseline for some experiments. This is the performance of the model after the SFT step (but before IPO) and as explained in Section 4.2 is the same as context distillation.

Experiment setup. Unless otherwise specified, we use Llama 3 8b Instruct or Gemma 2 9b it as the base model for query generation. We use ColBERTv2 (Santhanam et al., ) as the retriever. For the reward function, we use the average precision of the retrievals, so $\mathbb{R}=AP(C_{hi})$.

### 5.1 Results on HotpotQA & HoVer

In terms of retrieval recall, LeReT improves recall by 9–22% on HotPotQA and 27–29% on HoVer relative to the Llama and Gemma unadapted instruct models (“base”). This substantially exceeds the gains achieved via few-shot prompting alone, showing that sampling from multiple few shot prompt ensembles and training the model with RL is crucial. The gains also compounds over hops, possibly because lower quality search queries at a given hop distract future steps. We feed the improved retrievals into Llama 3.1 70b, asking it to generate a response to the question using the provided context. We find that improving retrieval produces a corresponding improvement in generations, with the generator exact match increasing at approximately half the rate of recall.

**Table 1: LeReT improves the quality of Llama 3 8b and Gemma 9b on HotpotQA and HoVer. We compare models trained with LeReT versus the base model and the base model with few shot prompting and measure the recall (RE) and average precision (AP) of the retrieved documents (higher is better) along with the exact match of generations produced using the retrieved documents.**
| Model | Method | 1 Hop | 2 Hops | 3 Hops | 4 Hops | Generator |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Dataset | RE | AP | RE | AP | RE | AP | RE | AP | EM |  |
|  | Base | 42.3 | 38.8 | 54.7 | 41.9 | — | 41.0 |  |  |  |
| Llama 8b | Few-shot | 49.9 | 45.6 | 64.8 | 53.9 | — | 47.1 |  |  |  |
|  | Few-shot all | 50.2 | 46.4 | 63.5 | 50.5 | — | 45.2 |  |  |  |
| HotpotQA | LeReT-CD | 51.4 | 47.3 | 69.8 | 58.0 | — | 49.3 |  |  |  |
|  | LeReT | 56.7 | 52.5 | 77.1 | 66.3 | — | 52.5 |  |  |  |
|  | Base | 52.2 | 48.4 | 70.9 | 57.7 | — | 51.0 |  |  |  |
| Gemma 9b | Few-shot | 54.4 | 50.4 | 66.7 | 57.8 | — | 48.5 |  |  |  |
|  | Few-shot all | 54.6 | 50.5 | 69.6 | 58.8 | — | 50.0 |  |  |  |
| HotpotQA | LeReT-CD | 53.5 | 49.6 | 71.9 | 59.2 | — | 51.4 |  |  |  |
|  | LeReT | 56.1 | 52.2 | 79.9 | 67.0 | — | 54.3 |  |  |  |
|  | Base | 37.9 | 34.8 | 45.6 | 37.9 | 48.5 | 38.3 | 50.0 | 39.3 | 61.5 |
| Llama 8b | Few-shot | 45.6 | 42.2 | 53.4 | 45.9 | 56.0 | 46.0 | 57.3 | 46.1 | 64.6 |
|  | Few-shot all | 38.8 | 35.8 | 51.9 | 44.4 | 57.5 | 46.3 | 59.7 | 45.9 | 64.7 |
| HoVer | LeReT-CD | 42.9 | 39.8 | 56.6 | 48.4 | 63.2 | 52.2 | 66.9 | 54.3 | 67.5 |
|  | LeReT | 45.8 | 42.5 | 65.4 | 56.1 | 72.8 | 61.4 | 76.9 | 64.3 | 69.8 |
|  | Base | 40.8 | 37.7 | 45.5 | 38.1 | 48.8 | 39.6 | 50.1 | 40.4 | 61.7 |
| Gemma 9b | Few-shot | 46.3 | 42.9 | 55.4 | 46.8 | 57.9 | 48.4 | 59.3 | 48.5 | 64.3 |
|  | Few-shot all | 46.3 | 42.8 | 55.8 | 48.7 | 64.1 | 52.6 | 68.2 | 54.1 | 67.5 |
| HoVer | LeReT-CD | 45.2 | 41.7 | 59.5 | 50.7 | 65.3 | 54.1 | 69.0 | 56.2 | 67.2 |
|  | LeReT | 47.0 | 43.7 | 67.5 | 57.6 | 75.2 | 63.1 | 79.4 | 66.1 | 71.5 |

### 5.2 Iterative-LeReT

**Table 2: Iteratively applying LeReT leads to performance gains compared to standard LeReT. Gemma 9b and Llama 8b are tested with two iterations and recall and average precision are measured (higher is better).**
| Dataset | Model | Method | 1 Hop | 2 Hops | 3 Hops | 4 Hops |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| RE | AP | RE | AP | RE | AP | RE | AP |  |  |  |
| HotpotQA | Gemma 9b | Standard | 56.1 | 52.2 | 79.9 | 67.0 | — |  |  |  |
| Iteration 1 | 55.7 | 51.7 | 78.2 | 65.6 | — |  |  |  |  |  |
| Iteration 2 | 57.6 | 53.5 | 82.3 | 70.5 | — |  |  |  |  |  |
| HoVer | Llama 8b | Standard | 45.8 | 42.5 | 65.4 | 56.1 | 72.8 | 61.4 | 76.9 | 64.3 |
| Iteration 1 | 45.1 | 41.7 | 62.7 | 54.1 | 69.6 | 59.1 | 73.5 | 62.1 |  |  |
| Iteration 2 | 44.9 | 41.6 | 65.3 | 55.5 | 73.4 | 61.2 | 78.2 | 64.4 |  |  |

We evaluate the performance of applying LeReT for two iterations. Training with only half the data (iteration 1) results in slightly worse performance compared to standard non-iterative LeReT, but after the second iteration the model performs better than the LeReT model. That is, sampling data that is both more on-policy and higher scoring in the second iteration leads to improvement.

### 5.3 Factuality with different generators

**Table 3: The stronger the generator model, the more it benefits from improved retrieval. We test 4 different generator models using retrievals sampled from HotpotQA on the base model, few-shot prompted model, and LeReT-trained model. We report the recall of the retrievals (RE). We measure the exact match and F1 scores of the generated answers (higher is better).**
| Generator Model | Base (RE 54.15) | Few-shot (RE 63.60) | LeReT (RE 80.40) |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| EM | F1 | EM | F1 | EM | F1 |  |  |
| Gemma 2b | 13.8 | 21.6 | 16.6 | 24.5 | 18.9 | (+5.1) | 28.5 |
| Llama 3 8b | 35.1 | 44.6 | 40.4 | 50.2 | 46.9 | (+11.8) | 58.6 |
| Llama 3.1 70b | 38.1 | 47.7 | 45.6 | 56.3 | 53.5 | (+15.4) | 64.9 |
| GPT4 | 33.4 | 43.3 | 41.6 | 52.7 | 50.7 | (+17.3) | 62.9 |

Improving retrieval seeks to improve LLM grounding. Intuitively, stronger models with better reasoning capabilities should benefit more from having the correct documents to reason with than weaker models that may not be able to generate the correct answer even with the right documents. To assess this, we take the retrieval output by various Llama 3 8b models for HotpotQA and condition various generator models with them. As seen in Table 3, stronger generators deliver higher quality and larger gains when supplied with LeReT-trained retrieval contexts. We note that although GPT4 has the largest improvement, it does not have the highest score. Examining the generations, we see that GPT4 very closely followed the instructions to “base your answers only on the provided context” and would output statements such as “answer cannot be found in the context” instead of trying to answer it anyway the way weaker models did.

### 5.4 Diverse Few-Shot Prompting versus High-Temperature Sampling

While prior work typically uses high temperature sampling to generate diversity, LeReT leverages few-shot prompting to generate diverse exploration data. To evaluate the effectiveness of few-shot prompt diversification, we consider alternate sampling strategies, particularly sampling from $\pi_{r}$ at different temperatures with no few-shot prompting, a fixed few-shot prompt (fixed), or multiple few shot prompts (diverse).

First, we compute some statistics about the rewards generated by the sampled search queries: we compute the average number of unique rewards per question and the standard deviation of the rewards as a proxy for diversity, and we measure the percentage of questions where at least one query (gold star answer) achieves maximal reward as a proxy for quality of sampled data. We find in Table 4 that while sampling with higher temperature improves diversity in search queries, few-shot prompting leads to significantly higher quality data and using multiple few-shot prompts provides comparable diversity.

We train on four of the sampled datasets: (1) queries sampled with diverse few-shot prompting at standard temperature (0.7), (2) queries sampled at a high temperature (2.0), (3) queries sampled with diverse few-shot prompting at high temperature (2.0), and (4) queries sampled with a single fixed few-shot prompt at high temperature (2.0). We find that training a model using data sampled with few-shot prompting at temperature 0.7 results in the best performance, which is also the sampling strategy that results in the largest percentage of questions with at least one gold star answer. This suggests that exploration is critical to the success of RL training and justifies the extra effort of bootstrapping few shot prompts.

**Table 4: Sampling with higher temperature results in greater diversity of responses (higher unique ap, ap std dev) while few shot prompting results in better data (higher gold rate). Specifically, gold rate is defined as the percentage of questions for which we have a gold star response (a query that results in the maximal score). Unique AP is the number of unique average precision scores there are for a question, and AP std dev is the standard deviation of the average precision scores for a question. Data size is measured in terms of the number of preference pairs.**
| Model | Data size | Gold (%) | Unique AP | AP Std Dev |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Hotpot | HoVer | Hotpot | HoVer | Hotpot | HoVer | Hotpot | HoVer |  |
| @ temp 0.3 | 44,705 | 28,575 | 37.5 | 12.1 | 1.66 | 1.25 | 0.09 | 0.029 |
| @ temp 0.5 | 55,564 | 32,091 | 39.4 | 12.6 | 2.10 | 1.27 | 0.10 | 0.033 |
| @ temp 0.7 | 69,361 | 37,354 | 43.9 | 12.6 | 2.10 | 1.28 | 0.14 | 0.033 |
| @ temp 1.35 | 92,264 | 48,516 | 46.3 | 12.0 | 2.35 | 1.32 | 0.16 | 0.039 |
| @ temp 2.0 | 81,017 | 58,281 | 41.0 | 10.3 | 2.36 | 1.34 | 0.16 | 0.045 |
| Fixed few-shot @ temp 2.0 | 93,613 | 92,542 | 47.7 | 13.5 | 2.41 | 1.32 | 0.16 | 0.038 |
| Diverse few-shot @ temp 2.0 | 95,373 | 71,433 | 47.5 | 12.3 | 2.47 | 1.34 | 0.17 | 0.044 |
| Diverse few-shot @ temp 0.7 | 105,506 | 49,304 | 54.2 | 13.8 | 2.35 | 1.28 | 0.15 | 0.031 |

**Table 5: Diversifying few-shot prompts when sampling search queries result in more effective training datasets for RL. The standard LeReT with few-shot prompting at temperature 0.7 results in better performance than training on a dataset sampled at temperature 2.0 without few-shot prompting or a dataset sampled at at temperature of 2.0 with fixed few-shot prompting or a dataset sampled at at temperature of 2.0 with diverse few-shot prompting.**
| Model | 1 Hop | 2 Hops |  |  |
| --- | --- | --- | --- | --- |
| RE | AP | RE | AP |  |
| Base model | 42.3 | 38.8 | 54.7 | 41.9 |
| Few-shot | 49.87 | 45.58 | 64.77 | 53.86 |
| LeReT diverse few-shot @ temp 0.7 | 55.74 | 51.76 | 78.14 | 67.67 |
| LeReT @ temp 2.0 | 49.12 | 44.81 | 69.86 | 58.56 |
| LeReT fixed few-shot @ temp 2.0 | 50.89 | 46.69 | 70.79 | 59.93 |
| LeReT diverse few-shot @ temp 2.0 | 51.73 | 47.79 | 73.67 | 62.60 |

### 5.5 Different retrievers

Finally, we test whether LeReT is applicable to general RAG systems by swapping our retriever from ColBERT over Wikipedia to Azure AI Search, applied with the default configuration for full text search. We observe that the base Llama model performs very poorly compared to its retrievals with ColBERT. This is likely because Azure is not specialized to the Wikipedia index which is helpful for our multi-hop tasks. However, the query generating LLM can adapt to compensate for this weaker retriever, as we see significant improvement with few-shot prompting and LeReT. This demonstrates the power of LeReT to adapt to general blackbox tools in the pipeline. Given the poor performance of the base model, few-shot prompting based exploration (Section 5.4) is found to be necessary, versus simply sampling with high temperature.

**Table 6: LeReT greatly improves the performance of Llama 8b on Hotpot and HoVer with Azure AI Search used as the retriever. We perform the same sampling and training pipeline as all other experiments but use Azure AI Search instead of ColBERT.**
| Dataset | Method | 1 Hop | 2 Hops | 3 Hops | 4 Hops |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| RE | AP | RE | AP | RE | AP | RE | AP |  |  |
| Hotpot | Llama 8b | 10.6 | 9.1 | 18.5 | 15.0 | — |  |  |  |
| Few-shot | 39.6 | 34.7 | 50.7 | 40.8 | — |  |  |  |  |
| LeReT | 43.8 | 38.9 | 60.0 | 48.6 | — |  |  |  |  |
| HoVer | Llama 8b | 15.6 | 14.0 | 22.8 | 19.2 | 27.8 | 22.0 | 31.2 | 23.5 |
| Few-shot | 37.1 | 33.2 | 45.9 | 38.3 | 49.8 | 40.1 | 52.1 | 39.6 |  |
| LeReT | 39.1 | 35.2 | 51.9 | 44.5 | 58.6 | 48.8 | 62.6 | 51.3 |  |

## 6 Discussion

In this work, we introduced LeReT, a framework for improving the quality of multi-hop retrieval via reinforcement learning and thus enabling better grounding for LLM systems. Beyond retrieval specifically, this can be extended to learning for agentic systems or LLM programs that use other tools. LeReT conducts diversified exploration of search queries in each hop by sampling using varied optimized few-shot prompts. It then uses this to construct a preference dataset for every hop consisting of queries that lead to a diverse set of retrieved outcomes. To train the model, it first conducts context distillation followed by an iterative application of the IPO objective. Experimental evaluation on the HotpotQA and HoVer benchmarks with two different retrieval models reveals that LeReT can improve the quality of Llama 8b- and Gemma 9b-based systems by up to 29% in recall.

Limitations & Future Work. While in this work we have used direct supervision for retrieval, a fruitful effort would be to enable learning from indirect supervision such as the correctness of the final generative response. Another promising direction is learning by updating the tools themselves like training the retriever model used to encode the search queries and documents. Doing this would require changes to the sampling algorithm and addressing the signal-to-noise ratio but would likely lead to significant gains.

## Appendix A Sampling and Training Details

We sample with $P=4$ for HotpotQA and $P=3$ for HoVer. We implement our sampling pipeline on top of DSPy (Khattab et al., ), specifically defining a single hop as a program and sampling data using the evaluate functions. We also use chain-of-thought prompting when generating queries.

We use a learning rate of 1e-7 for SFT/context distillation in all our experiments, and use a $\tau=0.05$ and learning rate of 1e-7. We train SFT for 1 epoch, and we only distill the best performing prompt. We train IPO for 2 epochs.

### A.1 Data Scaling Analysis

We conduct data scaling experiments for LeReT. We evaluated a training run of Llama 3 8b on the full HotpotQA training set (90,447 questions), which resulted in 494,208 preference pairs after prompt driven diverse sampling. We find that the majority of the improvement occurs relatively quickly. Based on this, we only use a quarter of the HotpotQA training set for subsequent experiments. However, data scaling likely depends on a host of factors, including the task complexity and the base model, and we conducted the data scaling experiment to reduce the computational cost of our experiments.

Figure: Figure 4: The model performance saturates quickly. Measuring the test performance of Llama 3 8b as training progresses on the preference dataset collected using LeReT on the full HotpotQA train set (90,447 HotpotQA questions, 494,208 preference pairs).
Refer to caption: x2.png

For the retriever, we set up a local instance of ColBERTv2 with the Wiki 2017 abstracts index. For Azure AI Search, we created a custom index by uploading all the abstracts from the Wiki 2017 abstracts index. We use the default settings, only using standard text search with no semantic or vector search.

## Appendix B Additional Experimental Details

### B.1 Justifying Greedy Optimization

We run LeReT for two hops on all 90,447 questions in HotpotQA. After sampling the first hop, we chose two sets of documents that have different rewards. We then run the second hop with no few-shot prompting and evaluate the reward after the second hop. We find that the lower reward set of documents resulted in a higher reward after the second hop in only 0.026% of cases.

### B.2 Average precision

Average precision is defined according to Eq. 3 where $R$ is the total number of relevant documents, $P(k)$ is the precision of the first $k$ documents, and $\textrm{rel}(k)$ is 1 if the $k$th document is relevant and 0 0 otherwise:

$$ $\textrm{AP}=\frac{1}{R}\sum_{k=1}^{N}P(k)\cdot\textrm{rel}(k)$ (3) $$

### B.3 Multi-Hop Sampling

Can we get away without training on data from all hops? We run an ablation to determine the necessity of sampling across multiple hops. Sampling across multiple hops requires is computationally and less parallelizable. Specifically, we train Llama 3 8b on Hotpot and HoVer, sampling only the data from the first half of the hops. For Hotpot, this amounts to sampling from just the first hop and for HoVer, this amounts to sampling data from the first two hops.

**Table 7: Sampling from all hops instead of only the first few significantly improves performance. We train Llama 3 8b on preferences from only the first half of the hops in a pipeline, and compare to training on the full dataset containing preferences over queries from all the hops.**
| Dataset | Method | 1 Hop | 2 Hops | 3 Hops | 4 Hops |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| RE | AP | RE | AP | RE | AP | RE | AP |  |  |
| Hotpot | 1 hop | 58.8 | 54.7 | 70.8 | 62.5 | — |  |  |  |
| All hops (2) | 56.7 | 52.5 | 77.1 | 66.3 | — |  |  |  |  |
| HoVer | 2 hops | 45.5 | 42.2 | 62.8 | 54.3 | 69.7 | 59.3 | 73.6 | 62.2 |
| All hops (4) | 45.8 | 42.5 | 65.4 | 56.1 | 72.8 | 61.4 | 76.9 | 64.3 |  |

We find training on data from all hops leads to substantial improvement in performance across both the datasets, compared to training on only the first half leads to performance gains. The gain is larger for Hotpot where the task only has two hops, and thus never sees data where the context has additional documents from previous hops.

### B.4 Long form generations

We present a preliminary attempt at long form generation. The majority of LLM use cases are for long form generation, and as such we want to test LeReT’s ability to improve long form generations. In addition, it is more to difficult to evaluate the factuality of long form answers, meaning that evaluating the relevance of the documents it conditioned its answer on as LeReT does may be simpler. Current retrieval datasets focus on short question answering, leading us to generate our own long form dataset.

To create a dataset with open ended questions that still had correct retrievals, we prompted GPT for 20 broad topics. From each of those 20 broad topics, we prompted GPT for 500 topics, giving us a total of 10,000 topics such as “Injuries in American football” or “Effects of mobile radiation on human health”. We then fed those topics into Colbert and retrieved the top 10 wikipedia abstracts. We then prompt GPT with the 10 wikiepdia abstracts and asked it to come up with a question that required students to use exactly 3 of the 10 articles. This gave it the freedom to choose articles that were closely related and led to more natural questions than forcing it to use a given 3 articles.

We then train Llama 3 8b on this dataset using LeReT. We find an approximately 8.47% improvement in document retrieval. We create long form generations by feeding the retrieved documents into Llama 3.1 70B. We find that the LeReT-generations are superior to few shot prompting with a 55.56% win rate.

### B.5 Possible reward functions

**Table 8: Sampling data using the generator F1 score leads to poor quality data with many wrong preference pairs (high disagree values) and less data (lower data size). We sample preference datasets using the F1 score of the generated answer. Hard disagree is preference pairs where the ranking by the retrieval reward is swapped compared to the ranking by the generator reward. Soft disagree is preference pairs where the retrieval reward is equal but the generator reward has a ranking. Data size is the size of the preference dataset generated using each method.**
| Dataset | Disagree (%) $\downarrow$ | Data Size $\uparrow$ |  |  |
| --- | --- | --- | --- | --- |
| Hard | Soft | Generator | Retrieval |  |
| Hotpot | 25.09 | 38.46 | 96,766 | 163,644 |
| Hover | 31.48 | 33.03 | 10,488 | 88,448 |

Do we need direct supervision in LeReT for computing the reward function that outputs a reward for a given question and set of retrieved documents or can we get away with indirect methods for supervising retrieval quality? We currently use average precision of retrieved documents, which provides more direct supervision for retrieval but requires knowing a correct set of documents in advance, as is available in Hotpot/HoVer. But, there are settings where the optimal retrieved documents may be hard to specify in advance. In such cases, indirect supervision may be easier to provide, where the final generated answer conditioned on the retrieved documents is reviewed, and a reward is generated based on the verification of the final answer. Such supervision can be quite weak and have a high amount of noise, as the generator may answer correctly even when conditioned on incorrect documents (because of internal knowledge) or provide incorrect answers even when conditioned on the right documents.

To explore these different settings, we apply LeReT using the F1 score of the final generated answer as the reward. We condition the LLM on retrieved documents along with the actual question to generate an answer, and compare that to the correct answer. Formally, instead of using $\textrm{AP}(C_{hi})$ as the reward, we use $\mathbb{R}=F1(\pi_{g}(d,C_{hi}))$.

We find that the F1 score of the generator does not provide a very strong signal. For the preference dataset that we constructed using the generator, over 50% of the preference pairs are wrong. We split these incorrect pairs into two categories: hard and soft disagree. Hard disagree means that according to the F1 generation reward, $q_{i}\succ q_{j}$ but according to the AP retrieval reward, $q_{i}\prec q_{j}$. Soft disagree means that according to the F1 generation reward, $q_{i}\succ q_{j}$ but according to the AP retrieval reward, $q_{i}=q_{j}$. To reduce the number of soft disagrees, we experiment with adding a threshold for the difference in F1 score to form a preference pair, but find that over half the questions in HotpotQA and all the questions in HoVer have one word answers so this is not effective.

**Table 9: With the weaker signal of generation, LeReT is able to improve upon the base model but does not match the performance of using the retriever reward. We take the dataset sampled on Hotpot and train Llama 3 8b.**
| Model | 1 Hop | 2 Hops |  |  |
| --- | --- | --- | --- | --- |
| RE | AP | RE | AP |  |
| Base model | 44.2 | 40.6 | 55.5 | 43.0 |
| LeReT-Retriever | 56.7 | 52.5 | 77.1 | 66.3 |
| LeReT-Generator | 49.6 | 45.5 | 56.8 | 49.5 |

We also find that the datasets generated using the generator reward are significantly smaller than those generated using the AP retriever reward, for example about 8.4 times smaller in case of HoVer. Since HoVer has one word answers, the generator F1 score is less fine grained than the retrieval accuracy over 4 documents. This leads to a smaller preference dataset as LeReT provides contexts to the next hop only if they have not achieved the maximum score. In the one-word answer case, there could be queries that retrieve only some (or none) of the correct documents but give the generator enough context to guess or use prior knowledge to output the correct answer. Thus, with this sort of coarse reward, it is much more likely that a question will be excluded from subsequent hop even though the model has not output an optimal query to the retriever.

When we train a model on this data, we find that it significantly improves over the base model, but substantially under performs the case where the reward signal is derived from average precision of gold documents. We find that the first hop data is far better than the second hop data, (11.43% hard disagree compared to 37.70, 37.04 soft disagree compared to 39.78) which likely contributes to the decreased performance on the second hop.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: * Has similar methods been used for single-hop QA or RAG in general?
soundness: 3
strengths: * Well written paper, clear presentation
* Results are strong and convincingly support the claim that using RL to improve query generator works better than pure SFT.
summary: In multi-hop question answering, a model needs to perform multiple retrieval steps before arriving at an answer.  Since the reward (answer) is not known until the last step, this problem lends itself well to reinforcement learning (RL).  The paper proposes to optimize one component (the question generator for retrieval) in the multi-hop QA pipeline using RL.  The method uses direct supervision (gold retrieved docs) to first train a reward function.  Then a diverse set of queries are sampled from the model using varied prompts.  The rewards for these generations are fed into an RL algorithm (IPO) to improve the query generator.  The method improves substantially on pure SFT methods on HotpotQA and HoVer.
weaknesses: * A bit difficult to judge the novelty of the contribution.  Has similar methods been used for single-hop QA or RAG in general?  If so, the novelty here might be marginal, especially since the paper relies on direct supervision for the reward model.
* The two multi-hop datasets used are not natural and somewhat out-of-date.  It would be great to see the methods usefulness on more relevant tasks and benchmarks.  The long-form generation attempt in the appendix is interesting, and could perhaps be developed more and moved into the main text?

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. While iterative training improves retrieval accuracy, does it potentially overfit the model to specific multi-hop tasks, thereby impacting generalizability in other retrieval-augmented scenarios?
2. What is involved in adapting LeReT to new domains or types of queries that it was not originally trained on?
soundness: 3
strengths: 1. Introduces a unique reinforcement learning framework to improve retrieval accuracy in LLMs, especially for complex multi-hop queries.
2. Demonstrates the effectiveness of iterative training in enhancing the retrieval and grounding abilities of LLMs.
3. Compatible with various retrieval systems, including ColBERTv2 and Azure AI Search, indicating its broad applicability.
summary: This paper presents a framework called "Learning to Retrieve by Trying" (LeReT), which aims to improve the grounding of large language models (LLMs) through reinforcement learning (RL)-based retrieval. LeReT enables LLMs to generate queries, learn from trial-and-error, and enhance retrieval by using diverse few-shot prompts combined with preference-based reinforcement learning. LeReT's flexibility makes it adaptable across different retrieval systems, with potential applicability in broader retrieval-augmented generation (RAG) contexts.
weaknesses: 1. Primarily relies on direct supervision for labeling relevant documents, which may limit its scalability in cases where explicit relevance labels are unavailable.
2. Requires extensive computation due to multi-hop retrieval and diverse query sampling, making it resource-intensive.
3. The need for sampling across multiple hops is computationally intensive and less parallelizable, reducing scalability.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: - Line 76 "If LLMs can observe the retrieved documents for different search queries, they can learn which queries lead to better outcomes." What supports this claim? And if this is true, then why do you need the direct or indirect supervision to teach LLM "how to query"?
soundness: 2
strengths: - LeReT is applicable to general retrieval-augmented generation (RAG) systems and can adapt to different retrievers.
- LeReT significantly improves retrieval accuracy. Compared to the unadopted Llama and Gemma instruction models, the recall rate increases by 9-22% on HotPotQA and 27-29% on HoVer.
- It can be used iteratively: applying LeReT for two iterations shows that the model performance after the second iteration is better than that of the standard non-iterative LeReT.
summary: The paper presents LeReT, a framework for improving LLM retrieval and answer grounding using reinforcement learning. It uses prompt-driven diverse query generation, model optimization with preference-based RL, and reward labeling for retrieved documents. Experiments on HotpotQA and HoVer datasets show significant improvements in retrieval and downstream generation compared to baselines. Analysis reveals the importance of diverse few-shot prompting and LeReT's applicability across different retrievers. Limitations include the use of direct supervision, and future work may focus on indirect supervision and tool updating.
weaknesses: - The novelty assertion of the proposed method lacks clarity. Regarding the related work spanning from line 139 to 148, it remains ambiguous as to how the proposed method differentiates itself from those other methods. I comprehend that the proposed approach employs diverse query generation and IPO for preference learning. However, these seem to be more of incremental enhancements within an existing framework rather than representing a distinct novelty.
- Also, the experiments lack comparisons with the most relevant recent works. Only the basic few-shot prompt baseline is compared.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. On lines 218–219, are there any concrete examples illustrating the differences between BFRS-generated queries and high-temperature sampling queries?

2. Regarding line 260, what are the examples used in few-shot prompting? Why is few-shot prompting not feasible during testing? Is it due to considerations of inference efficiency?

3. As for section 4.3, are there any details about how rewards are computed?

4. For Iterative-LeReT and the discussion in Section 4.3, this multi-hop search process seems compatible with online RL training, such as using PPO, by incorporating process rewards at each hop and a final reward for the conclusion. Have the authors explored online RL training?
soundness: 3
strengths: 1. The motivation that enhancing RAG performance through learning to generate better search queries is clear and reasonable.
2. The experiments present the improvement in both retrieval quality and finally performance, which validate the soundness of proposed algorithm.
summary: The paper addresses the issue of hallucination in language models by enhancing their capability to generate effective queries for retrieving relevant facts, thereby improving the accuracy of model responses. The proposed approach, LeReT, generates diverse search queries by incorporating few-shot examples. It constructs comparative queries guided by the supervision of retrieval quality and optimizes the model using the IPO algorithm. The study empirically validates the LeReT framework, exploring various methods of collecting retrieval rewards and assessing performance across different retrievers.
weaknesses: 1. The writing and presentation of results in this work could be enhanced. On line 254, I think it should be, "In this work, we consider XXX."

2. Some baselines (https://aclanthology.org/2023.emnlp-main.585.pdf, https://openreview.net/pdf?id=vDvFT7IX4O, and https://aclanthology.org/2023.acl-long.99.pdf) could be added to both the experiments and the related works sections. Although these works may not directly focus on multi-hop retrieval, they fit broadly within the same topic as this work, i.e., "query expansion." These works focus on generating better search queries to enhance RAG performance.

3. Relying on annotated golden documents, referred to as "direct supervision" in this work, limits the vision of the study. In more general scenarios, collecting "indirect supervision" is more feasible. Moreover, signals from "indirect supervision" are the ultimate indicators for downstream tasks.

Meta-review: This submission introduces LeReT, a reinforcement learning framework that helps LLMS improve their search queries. The motivation is that LLMs often struggle with formulating the right queries. LeReT aims to address this by optimizing query quality through trial and error. The experiments show that the proposed method enhances the retrieval accuracy by up to about 30% and improving downstream evaluations by 17%. 

The reviewers identified its strengths as: 
- the empirical results suggest that RL improves query generation for multi-hop queries and retrieval accuracy. 
- the iterative training proposed brings performance improvement by enhancing retrieval and grounding.
- the proposed framework is compatible with various retrieval systems, making possible applications. 

It also received concerns on 
- novelty, the reviewers find that the approach seems incremental, with relatively limited novelty compared to existing RAG or QA methods.
- scalability, by relying on direct supervision, limiting scalability and requiring high computational resources for multi-hop retrieval.
- experiments, the experimental setup could be improved by employing latest datasets and comparisons with recent works.

After the rebuttal, reviewers 9WtD and cwbp updated their ratings to 6, and reviewers v1Yv and NW9U unfortunately did not engaged with the authors' rebuttal. Overall this submission receives the borderline ratings of 6, 6, 6, 6. Overall, the proposed method is empirically simple, flexible, and can be applied to any off-the-shelf retriever, making it a promising technique for enhancing LLM pipelines. Of course, as pointed out by the reviewers, the technical novelty does not form as the strength of this work. Given the relatively possible ratings and possible applications, this work at its current format receives an acceptance recommendation.

Decision: Accept (Poster)