ListT5: Listwise Reranking with Fusion-in-Decoder Improves Zero-shot Retrieval (2024)

Abstract: We propose LISTT5, a novel reranking approach based on Fusion-in-Decoder (FiD) that handles multiple candidate passages at both train and inference time. We also introduce an efficient inference framework for listwise ranking based on m-ary tournament sort with output caching. We evaluate and compare our model on the BEIR benchmark for zero-shot retrieval task, demonstrating that LISTT5 (1) outperforms the state-of-the-art RankT5 baseline with a notable +1.3 gain in the average NDCG@10 score, (2) has an efficiency comparable to pointwise ranking models and surpasses the efficiency of previous listwise ranking models, and (3) overcomes the lost-in-the-middle problem of previous listwise rerankers. Our code, model checkpoints, and the evaluation framework are fully open-sourced at https: //github.com/soyoung97/ListT5.

heading: 1 Introduction
text: Recent advancements on neural information retrievers have made significant progress in their semantic search capabilities. However, they still struggle in zero-shot or out-domain tasks where statistical retrievers such as BM25 (Robertson and Zaragoza, 2009) often outperform, a crucial challenge since the setting is closely related to real-world scenarios.
Until now, the field of zero-shot reranking has been generally driven by cross-encoder models (Rosa et al., 2022) such as MonoT5 (Nogueira et al., 2020) or RankT5 (Zhuang et al., 2022). These models rely on pointwise reranking of each passage, and thus lacks the ability to compare between passages relatively at inference time. This could lead to a suboptimal solution in the task of reranking, where discrimination and ordering between passages are crucial.
Recently, listwise reranking models (Ma et al., 2023; Sun et al., 2023b,a), which evaluates multiple
∗Work done during an internship at LG AI Research. †Corresponding author.
passages together, is gaining attention for its effectiveness in zero-shot retrieval. Listwise rerankers can condition on and compare multiple passages to calibrate the relevance scores better, and can reduce the inaccuracy of zero-shot predictions arising from domain shift, as theoretically supported by Xian et al. (2023), and empirically evidenced by a line of works such as Ma et al. (2023); Sun et al. (2023a).
However, existing approaches that attempt listwise reranking have limitations. DuoT5 (Pradeep et al., 2021) implements pairwise reranking, a form of listwise reranking as pair, which incurs quadratic time complexity to the number of candidate passages. On the other hand, listwise reranking using Large Language Models (LLMs) (Pradeep et al., 2023a; Sun et al., 2023b,a; Ma et al., 2023) sacrifice efficiency in another aspect due to large parametric model size, and also face the "Lost in the middle" problem (Liu et al., 2023; Tang et al., 2023).
In this work, we present LISTT5 (Fig. 1), a novel listwise approach for zero-shot reranking that overcomes the aforementioned limitations. LISTT5 jointly considers the relevancy of multiple candi-
2287
date passages at both training and inference time based on Fusion-in-Decoder (FiD) (Izacard and Grave, 2021) architecture. It outputs a sorted list of input passages in the increasing order of relevance, and employs a novel tournament tree structure at inference time for efficient sorting. With these, LISTT5 provides the following contributions:
(1) Computational Efficiency. LISTT5 improves efficiency over previous methods in two aspects. First, for reranking top-k passages given n candidates, LISTT5 achieves O(n + k log n) asymptotic cost, lower than O(n2) of pairwise methods and comparable to O(n) of pointwise methods (Sec. 3.2). We empirically demonstrate such efficiency through FLOPs analysis (Sec. 4.4). Second, while previous listwise reranking methods relied on LLMs to process long listwise inputs, we show that adopting FiD removes the dependency on LLMs and allows us to perform listwise reranking with smaller and more parameter efficient architectures, such as T5-base (Tab. 3).
(2) Robustness to Positional Bias. In addition to efficiency, we show that LISTT5 overcomes the “Lost in the middle” problem commonly encountered in LLM-based listwise rerankers (Liu et al., 2023) which tend to be positionally biased to passages presented in the first and last parts of the listwise input (Sec. 4.5) and are more robust to the change in initial ordering of the passage (Sec. 4.6). We attribute the robustness of LISTT5 to such bias to the nature of FiD, which distinguishes each input passage with identifiers, instead of positions as in LLMs.
(3) Zero-shot Performance. On top of efficiency and robustness, listwise reranking with LISTT5 demonstrates strong performance in zeroshot retrieval, compared to not only the pointwise and pairwise methods, but also listwise methods based on LLMs that are argued to be specialized for zero-shot (Pradeep et al., 2023a,b). Specifically, on the BEIR benchmark for zero-shot retrieval, our approach using T5-3B surpasses state-of-the-art methods including pointwise RankT5 (+1.4 gain in NDCG@10) (Tab. 2) and listwise RankZephyr (+1.4 gain in NDCG@10) (Tab. 3). We further perform a comprehensive ablation study and find that our key components, such as tournament sort (App. J) and generating in the increasing order of relevance, benefit zero-shot retrieval (Sec. 4.7).

heading: 2 Related Work

heading: 2.1 Generative Models for Reranking
text: In the reranking scenario, rather than dual encoder models (Karpukhin et al., 2020) which separately encode query and passage information, models that see query and passage information jointly at inference time (Reimers and Gurevych, 2019; Nogueira et al., 2020) are shown to be effective for zero-shot retrieval (Rosa et al., 2022). Among those, formulating reranking as sequence generation, such as conducting listwise sorting (Ma et al., 2023; Sun et al., 2023b; Pradeep et al., 2023a) or generating rationales (Ferraretto et al., 2023), has shown an advantage in application to zero-shot retrieval by leveraging the language model’s auto-regressive generation capabilities. Specifically, a series of studies that use the encoder-decoder architecture of T5 (Sec. 2.2), and applying zero-shot reranking with LLMs (Sec. 2.3), or viewing reranking as autoregressive text generation problem (Wang et al., 2024) has been successful.

heading: 2.2 Listwise Reranking for T5
text: MonoT5 (Nogueira et al., 2020) leaverages predefined token probabilities (i.e., true/false) as relevance scores at inference time. RankT5 (Zhuang et al., 2022) introduces listwise training loss but both MonoT5 and RankT5 performs pointwise reranking at inference time. Built on top of MonoT5, DuoT5 (Pradeep et al., 2021), implements pairwise reranking, showing superior performance. However, DuoT5 only sees two passages at each prediction, and is inefficient as it has to run prediction on every pair of candidate passages (thus requiring n2 − n predictions to rerank n passages).

heading: 2.3 Listwise Reranking with LLMs
text: A line of work (Sun et al., 2023b; Pradeep et al., 2023a; Ma et al., 2023; Pradeep et al., 2023b; Qin et al., 2023) implements listwise reranking to LLMs, usually in a format of taking multiple (20) passages as input with the sliding window approach. However, this format presents a challenge due to the monolithic and lengthy input size. The model must process all tokens at once, limiting its applicability to LLMs trained with large context lengths. The lengthy input size also leads to the "lost in the middle" problem (Liu et al., 2023) for LLMs, exhibiting strong positional bias to the information in the first and last parts of long inputs, failing to comprehend relevant information
in the middle. This problem is also prevalent in listwise reranking (Tang et al., 2023). Furthermore, this approach comes at the cost of sacrificing computational efficiency in the already computationintensive reranking scenarios.
2.4 Listwise Reranking with m-ary Units Ai et al. (2019) is in a similar spirit to ours, as they define a basic ranking unit on m elements and extends it to rank the list of n(≫ m) elements. However, while they consider an intractable number of all m! orderings of all m-sized subsets and then employ Monte Carlo sampling for approximation, we use m-ary tournament sort algorithm which is complete and efficient by construction (Sec. 3.2).

heading: 3 Methods
text: Our method LISTT5 for listwise reranking has two components: (1) the basic operating unit that takes a fixed number of m passages and ranks the top-r based on FiD, and (2) an extension of this basic unit that takes full n passages and ranks the top-k based on tournament sort. We describe the basic unit in Sec. 3.1 and its extension in Sec. 3.2.

heading: 3.1 Basic Operating Unit (m → r)
text: The basic operating unit of LISTT5 processes a fixed number of m input passages and outputs topr passages (m → r), as in Fig. 2. We develop the basic unit upon the Fusion-in-Decoder (FiD) architecture (Izacard and Grave, 2021), which modifies the Encoder-Decoder structure of T5 (Raffel et al., 2020) to process listwise inputs efficiently. Specifically, given a query q and a list of m candidate passages [p1, ...,pm], our basic unit concatenates each passage pi with its index identifier i and the query q in the following format, and then feeds them to Encoder to obtain their full sequence token embedding hi:
hi = Enc("Question: q, Index: i, Context: pi") (1)
In Eq. (1), notice that each passage pi is encoded separately. Listwise reasoning upon multiple passages p1, ...,pm is handled by the decoder. Specifically, the encoded representations [h1, ...,hm] are concatenated to a single sequence and fed to the decoder, which performs listwise ranking and autoregressively generates an ordered sequence of the passage indices (identifiers) [i′1, ..., i ′ m] in the increasing order of relevance:
[i′1, ..., i ′ m] = Dec(concat[h1, ...,hm]),
where rel(q,pi′1) < ... < rel(q,pi′m) (2)
Importantly, in Eq. (2), notice that the decoder generates output passages from the least relevant one i′1 to the most relevant one i ′ m. This is different from previous listwise rerankers (Sec. 2.3), which generate from the most relevant passage index. Our rationale is that generating from the least relevant to the most relevant can be beneficial, as it may act a reasoning chain that progressively eliminates irrelevant passages to deduce the most relevant passages. One can imagine solving a confusing multiple-choice question; crossing out the options that are definitely not the answer until the last remaining option serves as a good strategy.
After the decoder ranks all m input passages, we decide the number r of relevant passages we will keep as the output of the basic operating unit. Namely, LISTT5 (r = 1) keeps one, so only [pi′m ] is selected as the output. LISTT5 (r = 2) keeps two, selecting [pi′m ,pi′m−1 ] as the output. Larger choices of r are possible in principle, but since we have observed saturation of performance for r > 2 in early trials, we only use the r = 1 and r = 2 variants of the basic unit in our experiments. For m, we set its value to 5 in our experiments. Ablations on the choice of m can be found at App. B.1.

heading: 3.2 Extension with Tournament Sort (n → k)
text: While the basic operating unit of LISTT5 (Sec. 3.1) reranks a fixed number of m (= 5) passages, our end goal is to rerank k passages given a much larger number of n (≫ m) candidate passages. This necessitates an algorithm to extend the basic unit (m → r) to full reranking (n → k). For the similar purpose, previous listwise rerankers (Sec. 2.3) has mostly used the sliding window algorithm. In these, an operating unit m → r, typically an LLM, is slided over the n candidate passages, and at each step m passages are locally reranked and reordered. After the sliding is done, the top k passages are used as the output of global reranking.
However, we observe that sliding window has a drawback. Since a window of size m can only "cache" up to m passages, full reranking n → k is bound to be inaccurate when k is set to be > m. In such cases, it is necessary to run the whole sliding over the entire n passages multiple times (e.g., ⌈ km⌉ times). Each sliding run would cost O(n) asymptotically, which can be computationally demanding given n ≫ m. Therefore, for LISTT5, we opt into developing a novel algorithm that does not require multiple evaluations over the entire n passages.
Our inference algorithm for LISTT5 that extends the basic unit (m → r) to full reranking (n → k) is inspired by the tournament sort algorithm (McLuckie and Barber, 1986) (App. C.1). Given n inputs, tournament sort ranks top-k by (1) constructing a binary tournament tree of n inputs where the root is the top-1 element, and (2) running k iterations of extracting the root and re-doing the tournament with the remaining inputs. Here, a crucial property is that once the tournament tree has been constructed, re-doing the tournament only requires recomputing a single path that traverses from a leaf to the root. As a result, most of the nodes and edges can be cached and reused over the k iterations, and each iteration only costs O(log2 n) asymptotically. Unlike sliding window, multiple evaluations over the entire n inputs is avoided.
Based on tournament sort, our inference algorithm n → k for LISTT5 is defined by (1) extending from binary to m-ary tournament trees, and (2) invoking the basic unit m → r (Sec. 3.1) at each node of the tournament tree. Specifically, given an arbitrary number of n passages, we perform a bottom-up comparison using the basic unit to construct an m-ary tournament tree. Then, we run k iterations of extracting the top-1 passage at the root and re-doing the tournament by recomputing a single path from the replaced leaf to root. In this way, the model can rank top-k passages from an arbitrary number of n passages while inheriting the efficiency of tournament sort. Fig. 3 illustrates our inference algorithm using LISTT5 (r = 1) as the basic unit. Further details can be found at App. C.
Asymptotic Complexity. We now present an asymptotic analysis of the cost of listwise reranking n → k with LISTT5 using a basic unit m → r. At the first iteration of tournament sort, we need to construct the full tournament tree, which amounts to n( 1m + r m2 + r 2 m3 + ...) = nm m m−r evaluations which is O(n). In each iteration afterwards, we
only need to recompute a single path from the leaf to root to compute the top-1, resulting in an asymptotic cost of O(logm n). With k iterations, LISTT5 achieves O(n+k logm n) asymptotic cost for reranking top-k from n candidate passages. If we compare this complexity with others (Tab. 1), we can see that LISTT5 is more efficient than pairwise reranking models of O(n2) (Pradeep et al., 2021), and comparable to pointwise models of O(n) (Nogueira et al., 2020; Zhuang et al., 2022).

heading: 4 Experiments

heading: 4.1 Overview
text: In this section, after explaining the training and evaluation details, we present three main results in the following order: (1) General performance and efficiency comparison of our models with respect to pointwise and listwise ranking models at Sec. 4.4, (2) Analyzing the lost-in-the-middle problem by measuring the robustness to positional bias between LISTT5 and listwise ranking models at Sec. 4.5, and (3) Ablation experiments on the design choice at Sec. 4.7. All results are based on the T5-base model except explicitly mentioning 3B.

heading: 4.2 Training
text: To train LISTT5, we use the official train subset of the MS MARCO (Bajaj et al., 2018) passage ranking dataset.2 The dataset consists of 532,761 distinct queries and 8.8M passages, with binary annotations of relevancy. Since the ordering of rel-
1https://en.wikipedia.org/wiki/ Comparison_sort
2https://microsoft.github.io/msmarco/ Datasets
evancy between negative passages is not provided, we use a dual-encoder retrieval model, specifically COCO-DR large (Yu et al., 2022), to retrieve Top1000 passages and label relevance scores of negatives for the training dataset of MS MARCO. Experiments using GTR (Ni et al., 2022), the same model used to build the training data for Zhuang et al. (2022), are reported at Appendix. B.2. For each query-positive passage pair, we randomly sample 20 groups of m− 1 distinct negative passages. We randomly shuffle the positive and negative passages and assign identifiers {1, ...,m} to them to form each training data. We train T5 with two different model sizes: base and 3B. We conduct grid search (App. F) on the subset of BEIR on the learning rate and number of steps in a reasonable range and report the best scores. As a result, we report the T5-base model
trained for 20k steps with a learning rate of 1×10−4 and T5-3B for 3k steps with a learning rate of 1× 10−5, both with linear learning rate scheduler with 10% warmup and an effective batch size of 256 in bfloat16 precision. Maximum input length is set to 230 and 128, and the maximum output length to 7 for T5-base and T5-3B, respectively. With DeepSpeed stage 2 optimization, training T5base took approximately 8 hours on 4×NVIDIA RTX A6000 GPUs with 48GB, while T5-3B training took 3 hours on 8×NVIDIA A100 GPUs with 40GB.

heading: 4.3 Evaluation
text: We measure the evaluation performance on the official dev set of MS MARCO (passage ranking dataset), TREC-DL19, and TREC-DL20 (Craswell et al., 2021) for in-domain performance, and the BEIR benchmark (Thakur et al., 2021) for zeroshot out-domain performance. BEIR contains 18 diverse sets of domains and tasks. We download the dumped index of the Top-100 and Top-1000 retrieved passages by BM25 from the official Pyserini repository. Reranking results using advanced first-stage retrieval models (e.g., COCO-DR) are reported at App. D.1. We use the evaluation metric of the Normalized Discounted Cumulative Gain@10 (NDCG@10) (Järvelin and Kekäläinen, 2002), the official evaluation metric for BEIR (Thakur et al., 2021). All reported scores are rounded to the nearest tenth. We also report the Mean Reciprocal Rank@10 (MRR@10) scores at App. Tab. 11. For reproducibility, we include the evaluation details including details to run baseline models and links for dataset download at App. G.

heading: 4.4 Zero-shot performance and efficiency.
text: Performance. We measure and compare the performance of LISTT5 against pointwise ranking models (MonoT5 (Nogueira et al., 2020), RankT5 (Zhuang et al., 2022)) in Tab. 2, and against pairwise and listwise ranking models (DuoT5 (Pradeep et al., 2021), RankVicuna (Pradeep et al., 2023a), RankZephyr (Pradeep et al., 2023b)) in Tab. 3. LISTT5 (r = 2) achieves an average of +1.3 point gain on NDCG@10 than RankT5 for reranking on BM25 Top-100. Also, the gain from listwise reranking improves even further when we rerank from BM25 Top-100 to Top-1000. While pointwise models show small performance difference from BM25 Top-100, LISTT5 improves from 50.9 to 51.8, additional 0.9 % gain from BM25 Top-100. Additionally, LISTT5 also excels on 3B model variants, outperforming RankVicuna7b and RankZephyr-7b on the selected subset of BEIR. We additionally provide qualitative analysis at App. I. Efficiency in FLOPs. In addition to comparing the
computational complexity in Sec. 3.2, we also conduct real-time measurements of floating point operations (FLOPs) using the FlopsProfiler of the DeepSpeed library3. We measure the FLOPs needed to rerank Top-10 passages from BM25-Top100 candidate passages for TREC-DL19 (43 queries, maximum input length of 256) on T5-base, run the profiler, and report the relative FLOPs when we set the FLOPs of MonoT5 (pointwise model) as 14. We also report the performance and FLOPs of the sliding window variants of LISTT5, with details at App. J. The results in Fig. 4 shows that LISTT5 (r=1) and (r=2) are comparable with MonoT5 and RankT5 (pointwise ranking models), and much more efficient than DuoT5 (pairwise ranking models). Also, tournament sort uses output caching to lower down FLOPs than the sliding window variants, with better performance, on the real-time FLOPs calculation (App. J). Additionally, we can parallize computation of the same level (e.g., leaf node) within query for tournament sort, while the sliding window approach should be computed sequentially. Even better, the LISTT5 model is flexible - according to their needs, users can have the choice to select between the trade-off of inference speed (r=1) and performance (r=2), an option not available for other models.

heading: 4.5 Robustness to Positional Bias
text: Background. One of the biggest problems of lengthy input of zero-shot listwise rerankers is the lost in the middle problem (Liu et al., 2023). Recent studies show that LLMs exhibit strong positional bias to the information in the first and last
3https://deepspeed.readthedocs.io/en/ latest/flops-profiler.html
4The exact value of FLOPs for MonoT5 in this setup was 229,732,539,806,400.
parts of the input, and often fail to comprehend relevant information in the middle of a long input. A recent work also pointed out that this positional bias problem is also prevalent in applying LLMs to listwise reranking (Tang et al., 2023). The main problem arises from the different assignment of positional encoding. We believe using the FiD architecture effectively addresses this issue, as each passage is processed by the encoder with identical positional encoding. Consequently, the decoder cannot exploit positional bias. To validate our statement, we conduct a comparative study to answer the following questions:
(1) How sensitive is the accuracy of each model to the position (location) of the positive passage?
(2) How often does each model consistently point to the same passage under position changes?
Baseline Models. We experiment with DuoT5 as representative for pairwise methods, and GPT3.5-turbo-1106 and GPT-4-0613 from OpenAI (OpenAI, 2022), the main model used for RankGPT (Sun et al., 2023b), as representative for listwise reranking methods. Note that we only
consider the top-1 prediction of each model, so the choie of LISTT5 (r=1) and (r=2) does not affect the metric. Detailed explanation about setups with example prompts are in Appendix H.
Experiment and Data Setup. We use the BM25 top 100 retrieved results from the FiQA-2018 and TREC-COVID test subset. For listwise ranking models, we randomly sample negative passages per every positive passage in every query to make groups of [1 positive, 4 negatives].5 Since pairwise models only take 2 passages for input, we additionally split the original group into 4 groups of [1 positive, 1 negative] for DuoT5. Similar with Tang et al. (2023), we measure the accuracy and agreement ratio after swapping the order of positive passages for each group (Fig. 5). The results in Tab. 4 show that (1) our model suffers less from the positive index change with (2) a higher agreement ratio. Since each passage is distinguished by identifiers instead of positions, LISTT5 effectively overcomes the positional bias from long inputs by separately encoding each query-passage pair at the encoder and aggregating the output at the decoder. Still, the decoder can utilize and integrate the encoded information of all passages and effectively perform listwise reranking, achieving a better zero-shot performance than LLMs (Tab. 3) or non-listwise counterparts (Tab. 2).

heading: 4.6 Impact of initial ordering
text: All listwise reranking methods, including the tournament sort and the sliding window approach, depends on the initial ordering returned by the firststage retriever (e.g., BM25). This may leave a room for ordering sensitivity. To investigate this, we experiment on DL19, DL20, and the selected subset of BEIR, to measure the robustness of initial ordering. For each dataset, we shuffle the initial ordering of candidate passages on 3 different seeds (seed 0,1,2) and report the average score. The results from Table 5 show that (1) ordering sensitivity is indeed prevalent in previous listwise reranking models, and that (2) using LISTT5 with FiD greatly reduces the sensitivity in general (in line with our findings in Section. 4.5), and (3) When using LISTT5, tournament sort is in general more robust to ordering change (-0.4 drop in average performance), compared to sliding windows (-1.2
5For TREC-COVID, one positive passage were sampled from each query since it has an average of 493 positive passages per each query.
drop). This means that LISTT5 with tournament sort can perform in a robust way even in conditions where the initial ordering is not very trustable, which is mostly the case for zero-shot retrieval tasks.

heading: 4.7 Ablation Study
text: To break down the role of each feature in our method, we perform experiments with different variants of our model (Fig. 6) in Tab. 6. Additional ablation experiments, such as varying m, are in App. B.1.
r = 1 vs r = 2. Conducting inference by (r = 2) improves the average BEIR performance by 0.3, compared with that of (r = 1). Since this gain is also applicable to the Relevant First variants, which is the model trained to generate relevant index first,
we hypothesize that r = 2 serves as giving a second chance for the model to view passages with different candidates to make a decision with different viewpoints, where there are confusing passages (hard negatives), resulting in better ability to rank.
Discrimination vs Sequential Sorting. Given the same setup and dataset, we also train the model to output only relevant index, annotated as Relevant Discrimination, similar to Hofstätter et al. (2022). However, the Relevant Discrimination model shows the lowest performance amongst all model variants (47.9). We hypothesize that training the model to distinguish and order between negatives provides additional information for the model. While tasks that only generate positive indexes only learn the decision boundary between positive and negative contexts, learning to order negatives provides more informative signals and more accurate ranking results, since the model additionally learns to calibrate between any kind of passages.
Relevant First vs Relevant Last (LISTT5). We also compare models by changing the ordering of
the output. Compared to LISTT5, Relevant first shows a performance drop of 1-2 points in average on BEIR. As explained at Sec. 3.1, we conclude that generating in reversed order is important, as it effectively eliminates false negatives and acts as a reasoning chain.

heading: 5 Conclusion
text: We proposed LISTT5, a FiD-based listwise reranking model that jointly considers multiple passages as input and generates an ordered list of passages, in increasing order of relevance. LISTT5 outperforms others in BEIR, with a remarkable +1.3 gain of average NDCG@10 performance. LISTT5 is efficient, leveraging tournament sort to its advantage. Finally, we show that LISTT5 overcomes the lost-in-the-middle problem in LLMs, and are more robust regardless of the initial ordering of the passage.

heading: 6 Limitations
text: We believe that the efficiency of our models can be greatly optimized using simple ideas. For example, if we can implement early stopping at sequential decoding (assuming that the model outputs permutation of 5), we can reduce the decoding step by 80% for LISTT5 (r=1) and 60% For LISTT5 (r=2). There could also be other options, such as designing a more efficient way that uses the tournament sort with fewer number of forward passes, efficient way of encoder output caching, and extension to other langauges or other architectures.
We believe there are still space for optimization of LISTT5, for example trying out m other than 5 or 10, exploring with different learning rate or batch size on training, and so on. However, we were only able to experiment a few due to resource and time limitations.
Our results are mainly reported with BM25 Top100, BM25 Top-1000, and COCO-DR Top-100 as first-stage retrieval modules. Also, our main results are based on the T5-base model and only a few were experimented with 3B models, due to the resource constraints. We hope to evaluate on extended setups for future work.

heading: 7 Acknowledgements
text: We greatly appreciate the members from the EXAONE lab from LG AI research for providing GPU resources to conduct experiments along with the helpful feedbacks. We would also like to thank the members from the SNU Language & Data Intelligence lab for giving constructive feedbacks to improve the paper. We also thank the anonymous reviewers from ARR December and ARR February for pointing out important discussion points and additional experiments that help support our claim. Lastly, we would like to thank Jinwoo Kim from School of Computing, KAIST for helpful discussions.

heading: A Related Work - FiD in a Similar Setup
text: Hofstätter et al. (2022) assigned index numbers to each query and passage pair, directing an FiD model to generate relevant passage indexes—an idea initially proposed by Lakhotia et al. (2020). While their approach is similar to ours, it diverges in that they only generate a single positive index, not the sorted list of all indices.

heading: B Design Choice of LISTT5
text: B.1 Impact of the number of passages m LISTT5 sees at once
This aligns with Sec. 4.7 from the main paper. In addition to varying the output format, we try to increase the number of passages m the model sees at once, with variants on r as well (See Sec. 3.1 for basic notation). The results from Tab. 7 show that setting m as 10 is not as effective as setting m as 5. We conjecture that there is a trade-off between the (1) benefits from seeing more negatives at once, and (2) the complexity of the ordering task itself. If
we increase m, the model can get more information, but at the same time, the task becomes very hard, and the boundary of negative order becomes very weak (and not very informative). Therefore, in the case of T5-base models, we find that 5 performed better than 10 passages. Compared to the original FiD for QA (Izacard and Grave, 2021) where they use large m (=100), ListT5 works best with smaller m. We conjecture the reason for this is that sorting task has more complexity than the original task that only use the input as knowledge source, leading to increased effectiveness when m is smaller. Where the use case of the original FiD are to find relevant information among inputs, LISTT5 needs to order between different inputs, a task that needs to analyze the relative relevancy between all given inputs. However, we believe the optimal number can be improved (or can be different) for models with different architectures or with larger parametric size.
B.2 Impact of the negative selection model
In our main experiment, we use COCO-DR to select and align negatives from MS MARCO, when constructing the training data. To analyze the impact of using COCO-DR as negatives, we also experiment with training ListT5 using negatives sampled from GTR,6 since RankT5 (Zhuang et al., 2022) used GTR to retrieve top 1000 passage from each query and conduct random sampling to select
6https://huggingface.co/ sentence-transformers/gtr-t5-xl
negative passages. (Note that RankT5 samples 35 negative passages per one query from the top 1000 retrieval results, while ListT5 only sees 4 negatives at once.) The results are at Tab. 8. First, we train the T5-base model with the same hyperparameter setup for those used to train the original LISTT5-COCODR model. 7 Then, we conduct hyperparameter search on the learning rate and number of steps for the GTR model, and found that training the model with learning rate of 1e-05 for 30k steps performs best (average 50.5). The results indicate that while LISTT5 trained with different negatives can impact performance, the performance gap is not significant, and the ListT5 model based on both COCODR and GTR still exhibit better performance than RankT5.

heading: C Details about Our Inference Framework
text: This aligns with Sec. 3.2 from the main paper.

heading: C.1 Background: Tournament Sort
text: Tournament sort is a variation of heap sort, inspired by the concept from sports tournaments, where its objective is to identify not just the best player, but also the k-best, with the minimum number of games. While naive selection sort takes O(n) operations to iteratively select the best element, tournament sort leverage its tournament tree structure for efficient sorting, resulting in needing only O(log n) operations after the initial building of the tree in O(n)

heading: C.2 Modification to Accept LISTT5 (r = 2)
text: Fig. 7 illustrates and compare the inference scenario for LISTT5 (r = 1) and LISTT5 (r = 2). Since the (r=2) variant outputs 2 different passage indices, the total number of candidate passages we need to compute is multipled by 2 for the next level of a tree. For example, if we use LISTT5 (r = 1) with m = 5 at the initial iteration, after computation of the bottom-level, we would get a total of 20 (100 / 5) filtered candidates which will go to the next round for comparison. In contrast, if we use LISTT5 (r = 2) with m = 5, we would get a total of 40 (100/5 ∗ 2) candidates to compute at the next round. However, it is important to note that we only use the inference method of (r = 1) for
7With learning rate of 1e-04, linear learning rate scheduler with 10% warmup, effective batch size 256, maximum input length 230, and maximum output length of 7, and train the T5-base model for 20k steps.
the root computation, since we always outputs the top-1 candidates for every iteration.

heading: C.3 Details on Random Replacement
text: As explained as the 3rd and 4th modification at the main paper Sec. 3.2, we explain in detail the random assignment process here. Unlike the original tournament sort where they mark the final selected values to infinity, it is not an option for us since we cannot define a passage that has infinity scores of relevance. Therefore, we choose to randomly fill out the place, by the following rules;
Random assignment of top-1 selected passage After one iteration, one index is selected as most relevant out of n candidate passages. Then, we add that index into the global exclude pool and remove the index from the consideration pool. After that, using the initial ordering of the passage by the firststage retrieval, we add +21 to the original selected index. (For example, if the selected index was 8, we replace that passage with 29. We just set it to a larger value than m=5 to avoid meeting duplicates, but it can be anything) If the index is already in the global exclude pool or have duplicates inside the input window m, we consider the next passage by adding 1 until the conditions are met.
Random assignment of dummy values to fill m The basic unit of LISTT5 always accepts exactly m passages as the input. However, there are cases when the leftover passages are not a multiple of m. For example, as we proceed to the upper level on the tournament tree, there will be a total of 100 7→ 20 7→ 4 passages left if we rank 100 passages using
LISTT5 (r=1) with m=5. In this case, we would need one more dummy passage to make 4 candidate passages to 5. For reproducibility, we select a dummy passage in a deterministic way by considering the first passage from the initial candidate passage pool. If that passage is already selected as top-k indices during the previous round or we have duplicates inside the input window m, we proceed to the next index until the conditions are met. To show that the assignment of the random index is not statistically significant, we have conducted additional experiments on the subset of BEIR with differing the random replace index number. The results are presented at Table. 9. From the table, we can see that the output is robust to the assignment of random replace index number.
Edge Cases. There are some cases, especially for the case of NFCorpus, that the initial retrieval module doesn’t give exactly n passages as initial candidate passages. Sometimes, they give n that is smaller than m (e.g., 1,2,3,4). For this case, we exceptionally allow duplicates within the input window m, run one basic unit of LISTT5 with (r=n) (We remove duplicate passage indexes so that the output ordering reduces to n). That is, we only run the inference once, and use the output ordering as it is. Also, if k is bigger than n-m, we inevitably meet the case where the leftover (unselected) passage number becomes smaller than m. (For example, ranking the 96th candidate passage for n=100 with m=5). Similar to the previous case, we also allow duplicates for this case and run the basic unit once to order the leftover indices.

heading: C.4 Example Scenario using Output Caching
text: For example, if we consider reranking top 10 passages from 100 candidate passages (n = 100, k = 10), without output caching results in 250 forward passes in total; since we would need ((100/5) + (20/5) + 1) = 25 forward passes for each iteration, the total will be 25 * 10 = 250. With output caching, after the initial iteration, we only need to do one computation for each level of a tree, resulting in (1+1+1) = 3 forward passes. Summing up results in 25 + 3*9 = 54 forward passes, almost reducing 80% of the total number of inferences.

heading: D Additional Results.
text: D.1 Results on COCO-DR as first-stage retrieval model.
We also conduct reranking using the Top-100 results of COCO-DR-large (Yu et al., 2022), and compare reranked results with MonoT5 (Nogueira et al., 2020), RankT5 (Zhuang et al., 2022), and LISTT5. For this experiment, we could only utilize the evaluation subset that is uploaded (fully open) in the BEIR repository.8 For simplicity, the input token length is fixed to 512 for first-stage retrieval with COCO-DR. From the results at Tab 10, LISTT5 achieves an average of +1.5 point gain for reranking on COCO-DR Top-100, additionally showing its applicability and effectiveness on both lexical-based (BM25) and neural-based first-stage retrieval modules.

heading: E MRR scores
text: Table 11 reports the corresponding MRR scores for BEIR evaluation on the main table.

heading: F Hyperparameter Optimization Methodology
text: We conduct a structured grid search strategy on a selected subset of the BEIR dataset. The selection
8Thus, results for BioASQ, Signal-1M, TREC-NEWS, Robust04 are not computed.
of hyperparameters for investigation was informed by prior research and best practices within the domain, specifically referencing the work by (Zhuang et al., 2022), which demonstrated effective use of a learning rate of 1× 10−4. To explore the potential for further optimization, we extended the search to include lower learning rates down to 1×10−5, considering the sensitivity of large models to learning rate adjustments.
We employed a linear learning rate scheduler with a 10% warmup over 10 epochs, a strategy for stabilizing training in the initial phases. The grid search was designed with a step size range from 10,000 to 30,000, increasing in increments of 10,000 steps.
For our 3 billion parameter models (3B models), due to their substantial computational requirements, we conducted a more granular evaluation. We assessed performance at every 1,000 steps between 1,000 and 10,000 steps.
This structured approach ensured that our hy-
perparameter selection was not arbitrary but based on a reasoned strategy aiming to balance computational efficiency with empirical performance. The specific choices of "250k steps" at a "1e-4" learning rate and "3k steps" at a "1e-5" learning rate were outcomes of this optimization process, identified as configurations that provided the best performance metrics within the constraints of our experimental setup.

heading: G Details on Evaluation Dataset

heading: G.1 Baseline Models.
text: We download and use the officially released checkpoints for the baseline model with the huggingface identifier of castorini/monot5-base-msmarco-10k, monot5-3b-msmarco-10k for MonoT5 (Nogueira et al., 2020), castorini/duot5-base-msmarco for DuoT5 (Pradeep et al., 2021),
castorini/rank_vicuna_7b_v1 for RankVicuna (Pradeep et al., 2023a), and castorini/rank_zephyr_7b_v1_full for RankZephyr (Pradeep et al., 2023b). For RankGPT(Sun et al., 2023b) using GPT-3.5 or GPT-4, we evaluate them using the OpenAI (OpenAI, 2022) API. For RankT5, we download the released T5X checkpoint from the official repository9 and convert it into a PyTorch checkpoint using the HuggingFace’s conversion script10. We evaluate DuoT5 on the same setup to the paper’s final experiments - we rerank 100 passages using MonoT5, select top 50 passages to be run on DuoT5, and aggregate relevancy scores of individual documents by the SYM-SUM method.
We run the official RankLLM repository11 to evaluate RankVicuna and RankZephyr on BEIR.

heading: G.2 Links, Maximum Input Length
text: Since the average length of query and passage differs greatly for each BEIR subset, we assign the
9https://github.com/google-research/ google-research/tree/master/rankt5
10convert_t5x_checkpoint_to_pytorch.py 11https://github.com/castorini/rank_llm
appropriate sequence length for each BEIR dataset and evaluate all models in the same setup. We download the dumped index of the top 100 retrieved passages by BM25 from the official Pyserini repository12, and download the inital query, corpus, and qrels from the BEIR repository.13
We referenced the average query + passage length from the official BEIR paper. We selected the smallest maximum length from [256, 512, and 1024], but is still bigger than the (sum of average query + passage length) multiplied by two(for better coverage). One exception is the trec-news, which added up to be bigger than 1024, but we just capped it to be 1024. The exact alias with the maximum input length is listed below;
‘msmarco’: 256, ‘dl19’: 256, ‘dl20’: 256, ‘treccovid’: 512, ‘nfcorpus’: 512, ‘bioasq’: 512, ‘nq’: 256, ‘hotpotqa’: 256, ‘fiqa’: 512, ‘signal’: 256, ‘news’: 1024, ‘robust04’: 1024, ‘arguana’: 1024, ‘touche’: 1024, ‘cqadupstack’: 512, ‘quora’: 256, ‘dbpedia-entity’: 256, ‘scidocs’: 512, ‘fever’: 256, ‘climate-fever’: 256, ‘msmarco_top1000’: 256,
12https://github.com/castorini/pyserini 13https://public.ukp.informatik.
tu-darmstadt.de/thakur/BEIR/datasets/
‘scifact’: 512

heading: G.3 Other Replication Details
text: Output validation module Upon experiments, we do not use constrained decoding or validation module to ensure the generation of valid permutations of 5. Each digital number is represented as simple integers (The decoded output looks something like "1 2 5 4 3" or "2 3 1 5 4"), with an exception catching module such that if the parsing fail, we go back to the original ordering. Even without any validation module, since LISTT5 is fine-tuned to output valid indexes for 20000 steps, if the input follows the correct format, the model almost always outputs valid index. Nevertheless, we think that adding a constrained decoding module would be beneficial.
Evaluation We run the same evaluation setup with the BEIR library to do evaluation. For example, we append title with a space along with the text(passage) part and treat as full passage. For evaluating reranked results for both BM25 Top100 and COCO-DR Top100 candidate passages, we remove duplicates before evaluation14 For CQADupStack, we follow the same procedure and aggregated all sub-domains ranging from android to wordpress to make 13,145 test queries, and report the average performance.

heading: H Details about the Experiment Measuring Positional Bias.

heading: H.1 Evaluation process.
text: We briefly explain here about the evaluation process for the FiQA dataset. We defined the positional bias inspired from Liu et al., [9], where they measure the answer accuracy with respect to the index change of the relevant passage.
1. We break down the original dataset into pairs of one query and one positive passage associated with the query. For each query-positive pair, we randomly sample 4 negative passages from the BM25 top100 results and additionally pair them to make one sample. Preprocessing them makes 818 distinct samples.
2. For every sample, we make 5 variants of the input text, so that the first one assigns index 1 to the positive passage, and the last one assigns index 5 to the positive passage. Note that only the index
14For example, quora had 1 (out of 10000) duplicates, so the NDCG@10 for BM25 may differ from the BEIR paper.
of the positive passage is changed, and we keep the order of other passages (negatives) as the same.
3. we forward the inputs to each model, and collect the output that corresponds to the most relevant index. To answer (1), we measure the accuracy with respect to the index of positive passage. To answer (2), we analyze the ratio of samples where the model points to the same passage regardless of positive index change.
We discard queries that doesn’t have positive indexes in the bm25 top100 dataset, or those that don’t have 4 distinct negative contexts. For reproducibility, all randomly sampled datasets used for experiments are conducted with fixed seed. (seed=0) Standard deviation are calculated using the numpy.std function.

heading: H.2 Prompt example.
text: To enforce a scenario where the model takes lengthy inputs at once, we apply the instruction format of permutation generation (text), and use the same prompt described in the RankVicuna (Pradeep et al., 2023a) paper. The prompts we use to give inputs to GPT-3.5-turbo-0301 are the following: I will provide you with 5 passages, each indicated by numerical identifier []. Rank the passages based on their relevance to the search query: {query}.
[1] {passage_1} [2] {passage_2} [3] {passage_3} [4] {passage_4} [5] {passage_5}
Search Query: {query}
Rank the 5 passages above based on their relevance to the search query. All the passages should be included and listed using identifiers, in descending order of relevance. The output format should be [] > [], e.g., [4] > [2]. Only respond with the ranking results, do not say any word or explain.
Given the above input, we collect the output of the LLM. Following the setup from Sun et al. (2023b), we use the ChatCompletion api by the openai library, with temperature of 0. Using the openai api, running the whole process cost about $35. To run ths GPT4 experiment on FiQA, it additionally cost 195.8$ (total of 6523910 input / 1298 output tokens). After the run, we found that 3 out of 818 outputs had malformed outputs, in a format such as: "[No relevant passage found] > ... [1]", rather than in a correct format such as: "[3] > [1] > [5] > [2]
> [4]". We discard those 3 malformatted instances with incorrect output formats into consideration and compared only with the rest. (That is, we also discard those instances for the FiD-T5 variant) To give an exactly same scenario to both models, we truncate each passages up to 512 tokens (based on the T5 tokenizer), since that is exactly what our fid model sees. After truncation, we also validated that all of the input sizes are below the range of 4096 (as the maximum input window size of gpt3.5-turbo-0301 is 4096)
H.3 Detailed analysis about pairwise methods
We find that pairwise models also exhibit positional bias, having a tendency to label the passage that comes at the front as positive. Theoretically, we can remove the positional sensitivity by evaluating all possible permutations of input passages (Murphy et al., 2019; Yarotsky, 2018). DuoT5 and other pairwise ranking methods (Qin et al., 2023) already include swapping orders and aggregate scores from both orderings. To measure the positional bias of pairwise models, in this experiment, we removed the averaging from swapping orders in DuoT5. However, the number of forward passes needed to mitigate positional bias problems in this way grows in a factorial scale, making it impossible and impractical to be applied to listwise methods. (We need 5! = 120 number of forward passes in order to remove the positional bias of 5 instances) In contrast, we effectively mitigate the positional bias problem, without any additional forward passes, with the Fusion-in-Decoder architecture.

heading: H.4 Experiments on the consistency of LLMs.
text: We ran the positional bias experiment (on GPT3.5) on TREC-COVID for 3 times to investigate the following: given the same input, does LLMs generate the same output multiple times? 15 The results from api calls at Tab. 13 were not always exactly the same, but the difference was negligible, not changing the main claims. For the case of LISTT5, it is deterministic and thus fully replicable. On running the same experiments on FiQA twice, we validated that the output files for LISTT5 are exactly the same.
15We were only able to run the inconsistency experiment on GPT3.5 due to the high inference cost of GPT-4.

heading: I Qualitative Analysis
text: Tab. 12 reports a sample output selected from the Arguana Dataset, which seeks the counterargument most opposed to the query argument .16 Considering the NDCG@10 reranking performance for MonoT5-base, RankT5-base, and LISTT5-base is 34.4, 35.5, and 48.9, respectively, LISTT5 excels on Arguana than other pointwise baseline models with a large margin. From inspection, we conclude that the listwise reranking nature of LISTT5 helps to discern and select which features are important in determining relevancy in this dataset, with respect to other passages.
We hypothesize that listwise comparison makes the model to favor counterarguments - (Different point of view, but the discussion topic is the same) over similar topics. For example at Tab. 12, RankT5 places passages that talks about accountability and criminal law in a moral aspect as the most relevant passage, which is quite similar to the original query (since it includes words such as ‘Prosecuting’) but not exactly the same about prosecuting offenders. Also, the passage that is scored highest from MonoT5 talks about ICC’s prosecution policy, but the original query is not related to ICC. In contrast, since perhaps LISTT5 is able to see different passages, it correctly determines the GT passage as top-1, giving more weight on talking about the same topic (even though the aspect can be different).

heading: J Measuring efficiency - Sliding window v.s. Tournament Sort.
text: We briefly describe the difference of tournament sort and the sliding window approach in Figure. 8. We conduct additional experiments to compare the efficiency of tournament sort and the sliding window.
J.1 Implementation Details.
We rerank top-10 passages from BM25 top100 candidate passages, for 43 queries of TREC-DL19. The latency and FLOPs for tournament sort variants are computed using our LISTT5 evaluation code, and the efficiency for the sliding window approach (without the FiD architecture) is computed using the official repository for RankVicuna
16The query is always included in the corpus, so for qualitative analysis, we excluded the passage that is exactly the same with the original query.
and RankZephyr.17 The FiD variant of the sliding window approach are computed using our LISTT5 evaluation code. We append the deepspeed FlopsProfiler for FLOPs measurement, which is the same as the ones that was appended for LISTT5. For a fair comparison, we also measure the FLOPs of the sliding approach on the T5-3b model18 and the T5-base FiD architecture using the LISTT5 code. Example commands used are as follows:
CUDA_VISIBLE_DEVICES=0 python ./src/rank_llm/scripts/run_rank_llm.py --model_path=castorini/lmsys/ fastchat-t5-3b-v1.0 --top_k_candidates=100 --dataset=dl19 --retrieval_method=bm25
17https://github.com/castorini/rank_llm 18we replace the model code from castorini/rank_vicuna_7b_v1 to lmsys/fastchat-t5-3b-v1.0 and measure FLOPs.
--prompt_mode=rank_GPT -- context_size=4096 --variable_passages --window_size 5 --step_size [2 or 3]

heading: J.2 Number of Required Forward Passes.
text: We calculate the number of required forward passes needed for variants of tournament sort and the sliding window approach at Table 14. Given a window size of 5, tournament sort is much more efficient to rerank top-10 passages, requiring fewer number of forward passes. This is because, unlike tournament sort with output caching, the sliding window approach requires re-evaluation over the entire input sequence, depending on the window size, stride, and the number of top-k passages to rerank. Detailed explanation of how we calculated the numbers from the table is below:
• After one pass of a sliding window of size 5 and stride of 4, we discard 4 passages and only carry (5-4)=1 previous passage to the next step as we move the window. Therefore, we would only be able to correctly order top-1
passages, since the top-2 passage cannot be moved.
• Therefore, to rank top 10 candidates, we have to iterate through at least ⌈10 / (5-4)⌉ = 10 times, which would result in a total of about 250 forward passes.
• For ranking top-6 with a sliding window of size 5 and stride 4, some forward pass can be saved in the 6th slide because top-5 have already been ordered in the first 5 slides. Therefore, a corrected precise calculation (noted as -> in the table) gives 248.
• The same applies to methods of stride=2 to 4.
• In contrast, tournament sort uses output caching, and after the initial computation (25 for r=1 and 31 for r=2), we only need to compute one path from leaf to root, which only costs only one additional forwards for each level of the tournament tree, which is 3 for (r=1) and 4 for (r=2).
• Therefore, by using tournament sort, we can efficiently reduce the number of forward passes needed to rank top 10 candidates.

heading: J.3 FLOPs comparision
text: In this section, we compare in detail on the choice of sorting method and architecture at Tab. 15.
T5 (FiD) v.s. T5 (no FiD). ListT5 uses the FiD architecture to effectively mitigate the positional bias problem and handle long inputs efficiently. Comparing with idx 7 v.s 8 (38.5 vs 53.8) and 9 vs 10 (25.6 vs 35.1) at Tab. 15, we can see that using FiD results in lower number of total FLOPs.
Tournament sort v.s. Sliding window on T5 (FiD). By comparing idx 5 and 6 with respect to idx 7 and 9, we conclude that the FLOPs to rerank Top-10 candidates are much lower for both (r = 1) and (r = 2) variants of tournament sort (36.3x and 66.0x), compared with the FiD variant of sliding window, for both (stride = 2) and (stride = 3) (154x and 128x). It also holds the same for models built on top of T5-base, by comparing idx (1,2) with respect to (3,4).

heading: J.4 Performance Comparison.
text: Comparison of FLOPs and performance on LISTT5 with the S.W(Sliding Window) approach and T.S(Tournament Sort) with different hyperparameters. LISTT5 (r=2) performs the best, with lower FLOPs than the sliding window variants on both setup of reranking top-10 and top-1 candidates.

heading: K Additional Experiments on Tournament Sort.

heading: K.1 Cases where m > k
text: In the main paper, we have discussed that the sliding window approach can be much more efficient when m « k. However, even when m > k, e.g., m = 20 and k = 10, the number of forward passes needed to get top-10 rankings for tournament sort can less than or equal to the sliding window variants, with simple modifications. For example, the
number of iterations to rank top-10 with m=20 and r = 10 with LISTT5 requires 9 forward passes if we take into account all top-r results from one iteration and take into account unwanted wins. Tournament sort with r=10 can correctly rank global top-10 candidates in one iteration, as illustrated at Fig. 9. This is the same amount of iterations needed with the sliding window approach with window size of 20 and stride of 10. We also compute the number of forward passes with different value of s, or r in Table. 17.

heading: K.2 Tournament Sort with LLMs.
text: We have also analyzed the performance of RankGPT (Sun et al., 2023b), listwise reranking with GPT3.5, with tournament sort. The performance difference of tournament sort with respect to the sliding window approach for w=20, s=10 were not significant, while the number of required forward passes to rank top-10 passages were the same (9) for both variants.

heading: Future Work
text: We hope to evaluate on extended setups for future work