On Speeding Up Language Model Evaluation

## Abstract

Abstract Developing prompt-based methods with Large Language Models (LLMs) requires making numerous decisions, which give rise to a combinatorial search problem.
For example, selecting the right pre-trained LLM, prompt, and hyperparameters to attain the best performance for a task typically necessitates evaluating an expoential number of candidates on large validation sets.
This exhaustive evaluation can be time-consuming and costly, as both inference and evaluation of LLM-based approaches are resource-intensive. Worse, a lot of computation is wasted: Many hyper-parameter settings are non-competitive, and many samples from the validation set are highly correlated - providing little or no new information. So, if the goal is to identify the best method, it can be done far more efficiently if the validation samples and methods are selected adaptively.
In this paper, we propose a novel method to address this challenge.
We lean on low-rank matrix factorization to fill in missing evaluations and on multi-armed bandits to sequentially identify the next (method, validation sample)-pair to evaluate.
We carefully assess the efficacy of our approach on several competitive benchmark problems and show that it can identify the top-performing method using only 5-15% of the typically needed resources—resulting in a staggering 85-95% LLM cost savings.

## 1 Introduction

Figure: Figure 1: Comparison of cost for finding the best model or prompt between our proposed algorithms (UCB-E, UCB-E-LRF) and Full Evaluation on two datasets. Left: AlpacaEval [] data as of May 20, 2024. The data includes 153 models evaluated on 805 instructions. The response on each instruction for each model is compared against a baseline response generated by GPT4-turbo, with GPT4-turbo being the LLM judge []. The monetary saving is calculated based on the inference cost of proprietary models among the 153 models and GPT4-turbo judging cost. Right: GSM8K [] prompt engineering data. The data includes 205 zero-shot prompts for Mistral-7B generated by GPT4 evaluated on 784 questions (10%) of GSM8K training set. The time saving is calculated based on inference speed of Mistral-7B using the Huggingface library with one Nvidia A6000 GPU. The overhead computation time for UCB-E and UCB-E-LRF is 2.4 and 142.6 seconds, respectively.
Refer to caption: extracted/5792625/figures/resource_savings_color.png

Large language models (LLMs) have demonstrated remarkable proficiency in diverse tasks such as question answering, machine translation and mathematical reasoning [, , ]. They are employed across numerous applications, ranging from automated customer support to content generation []. As the development of new LLMs continues, practitioners find themselves with a plethora of options, selecting the optimal model, prompt [], or hyperparameters for their specific needs from hundreds available. For instance, initiatives like the Chatbot Arena [] actively maintain nearly 100 models for benchmarking on user-specified open-ended queries. Similarly, the AlpacaEval [] project benchmarks over 200 models against a diverse set of 805 questions.

Querying an LLM is resource-intensive, and therefore such extensive evaluations require significant investments in time, compute and financial resources. Figure 1 (left) shows the estimated cost of a Full Evaluation of the 153 models officially included in AlpacaEval [] as of May 20, 2024 to be almost 800 USD.
Similarly, 78 Nvidia A6000 GPU hours are needed for evaluating 205 zero-shot prompts on 784 GSM8K [] questions using Mistral-7B [], Figure 1 (right).

Although it is common practice to exhaustively evaluate all validation samples of a given task for each method, practitioners often only care about the final aggregated performance rankings. In other words, the goal is to identify the top-performing methods, discarding the lower-ranked alternatives.
Consequently, evaluating on all validation samples is often unnecessarily costly and wasteful.

In this paper, we explore a limited-budget setting.
Given a *set of methods* we aim to identify the one that has the best average performance among a *set of validation examples* — given a fixed evaluation budget.
A simple baseline is to evenly split the budget for each method.
However, this can be very inefficient as it would spend a lot of the budget on obvious non-performers and too little effort on teasing out what the best methods are.
Intuitively, methods that consistently underperform other methods are unlikely to end up as the best.
Therefore, a more efficient budget allocation strategy is to spend less on low-performing methods and more on promising ones.
Multi-armed bandit algorithms enable this dynamic allocation by actively selecting the next method-example pair to evaluate based on the results of previous evaluations.

We propose two active selection algorithms UCB-E and UCB-E-LRF. Our first algorithm is an extension of the classical UCB-E [] to solve the multi-armed bandit problem.
It estimates the upper confidence bound (UCB) to guide the selection of the method which is paired with a randomly chosen example for the next evaluation in order to efficiently estimate the best method.
This algorithm enjoys a strong theoretical guarantee that the chance of selecting the best arm converges to 100% by an exponential decay of the number of evaluations.
Our second algorithm, UCB-E-LRF, leverages the
fact that in practice many validation samples are similar, and their results are highly correlated. In other words, if a method performs well on one sample, it will predictably also perform well on similar samples. We can therefore speculatively fill in those results and evaluate the method on a sample that is less correlated.
More formally, imagine we have $n$ methods and $m$ data points and store the evaluation results in a $(n\times m)$ matrix $E$. We can leverage the fact that this matrix $E$ is often low-rank, or can be approximated well by a low-rank matrix; evident from Table 3 and Figure 6 in Appendix A. We therefore regard the evaluation process as a matrix completion problem, where we predict the remaining unobserved $E_{i,j}$ entries by low-rank factorization (LRF) and prioritize evaluations of entries with large prediction uncertainties.
By deploying this approach in addition to UCB-E, UCE-E-LRF actively selects both the method and example to evaluate, which leads to even bigger budget savings in settings with correlated validation samples.

We evaluate the efficacy of these two algorithms, in addition to common non-active baselines, in a number of practical settings.
Our empirical analysis shows that our two active selection algorithms are much better than all baselines.
As predicted, the benefits of active selection are larger if the top methods are separated by a bigger performance gap.
Notably, we observe that UCB-E works best for such easier settings; and UCB-E-LRF shines in harder settings, when the performance differences between methods are more subtle.

## 2 Preliminaries

### 2.1 Evaluation Workflow in Large Language Model Applications

**Table 1: Selected benchmarks where LLMs are state-of-the-art methods. We group them based on the task type and whether additional LLM-based / human-based scoring is needed for evaluation.**
| Task Type | LLM Inference + Rule-based Scoring | LLM Inference + LLM-based Scoring |
| --- | --- | --- |
| Natural Language Understanding | BOLD [] GLUE [] HellaSwag []<br>SQuAD [] TriviaQA [] WinoGrande [] | CNN/Dailymail [] Newsroom []<br>XSUM [] |
| Open-ended QA | Google NQ [] HotpotQA [] QASPER [] | AlpacaEval [] Chatbot Arena []<br>MT-Bench [] |
| STEM and Reasoning | APPS [] Arc [] GPQA [] GSM8K []<br>MATH [] MMLU [] PIQA [] | – |

A typical evaluation workflow in large language model (LLM) applications involves three steps: inference, scoring, and performance aggregation.

- 1.
Inference. Given a dataset (see Table 1), the output is generated by a specific LLM-based *method*. Here, *methods* can differ based on their LLM architecture (architecture search), a prompt (for prompt engineering []), or specific decoding parameters (e.g. temperature, decoding strategies), or hyper-parameters.
- 2.
Scoring. The outputs from different methods are scored with a scoring function i.e. metric. The scoring function can either be rule-based (exact string match, BLEU [], ROUGE []), LLM-based (BERTScore [], LLM judge []), or human-based. Depending on the task and dataset format, researchers have employed different types of scoring functions. In Table 1, we classify a selected group of commonly used datasets according to the task type and scoring function applied to them. We group LLM-based and human-based scoring together since they are usually considered alternatives to each other and have been shown to have relatively high correlation [].
- 3.
Performance aggregation. The performance of each method is aggregated across the dataset, often with a simple average over all examples in the dataset, although many alternative aggregations are possible.

Both, inference and scoring do often rely heavily on LLM-based scoring through black-box APIs []—inducing large costs and resource consumption.
However, in many practical scenarios, we are only interested in identifying the best method among all methods. For example, for prompt engineering and hyperparameter tuning, knowing which method (prompt / configuration) is the best is usually sufficient for next round of iteration. Identifying exactly which method is ranked 84 out of 100 is irrelevant and frankly, a waste of resources.
We therefore claim that evaluating all methods on all examples of a dataset is excessive for this purpose, which motivates the research question how to identify the best method with as few evaluations as necessary.

### 2.2 Notation and Problem Formulation

Suppose we have a set of examples $\mathcal{X}=\{x_{1},\ldots,x_{m}\}$ and a set of methods $\mathcal{F}=\{f_{1},\ldots,f_{n}\}$, such that $f_{i}:\mathcal{X}\to\mathcal{Y}$. Let $e:\mathcal{Y}\to[0,1]$ denote our scoring function and without loss of generality, we assume $e(f(x))>e(f^{\prime}(x))$ indicates $f$ has better performance than $f^{\prime}$ on the example $x$.
Suppose $E\in[0,1]^{n\times m}$ is the underlying scoring matrix for a given problem $(\mathcal{F},\mathcal{X},e)$ by defining $E_{ij}:=e(f_{i}(x_{j}))$.
The score of a given method $f_{i}$ is defined as $\mu_{i}=\frac{1}{m}\sum_{j=1}^{m}E_{ij}$ and we want to find the best method
$i^{*}=\arg\max_{i}\mu_{i}.$
Formally, given a finite evaluation budget $T$, we want to study the evaluation algorithm ${\mathcal{A}}(\mathcal{F},\mathcal{X},T)$
and maximize $\mathbb{P}_{\mathcal{A}}(\mathcal{A}(T,\mathcal{F},\mathcal{X})=i^{*})$, the probability of returning the best method $i^{*}$ within budget $T$.

We introduce the following additional notation to allow for a clear description of the algorithms. Let $E^{\rm obs}\in\left([0,1]\cup\{?\}\right)^{n\times m}$ denote the partially observed scoring matrix, and $O\in\{0,1\}^{n\times m}$ denote the observation matrix where $O_{ij}$ indicates whether the method-example pair $(f_{i},x_{j})$ has been observed. Finally let us denote our estimate of $E$ by $\hat{E}$.

## 3 Algorithms

One simple baseline for designing the evaluation algorithm $\mathcal{A}$ is: uniformly sample and evaluate $T$ examples from $\mathcal{X}$, for each method $f_{i}\!\in\!\mathcal{F}$, estimate the performance $\hat{\mu}_{i}=\frac{1}{\sum_{j=1}^{m}O_{ij}}\sum_{j=1}^{m}O_{ij}\cdot E^{\rm
obs
}_{ij}$, and pick the method $f_{\hat{i}^{*}}$ with the highest estimated mean $\hat{\mu}_{\hat{i}^{*}}$ as the prediction for the best method.
This baseline ignores any information gathered in the process of sequentially evaluating examples, and, as expected, can be very inefficient.
We will see in the experiments that for some datasets, this baseline needs to evaluate at least $90\%$ of all method-example pairs to predict the best method correctly with high probability.
In the following section, we will introduce two adaptive algorithms that actively select the next method-example pair to evaluate based on previous results; Figure 2 illustrates this idea on a high level for prompt tuning. The methods in the figure are different prompts, and the examples are simple math problems.

Figure: Figure 2: Active method-example pair selection: After LLM evaluated $t$ method-example pairs, we then call Algorithm $\mathcal{A}$ to *select* the next method-example pair. Then we *query* LLM for evaluating this pair and *fill* the scoring received from LLM into the scoring matrix. Algorithm $\mathcal{A}$ then *updates* its internal status prepared for the next method-example pair selection. This process is repeated $T$ times and, in the end, the algorithm $\mathcal{A}$ predicts the best method $f_{\hat{i}^{*}}$.
Refer to caption: extracted/5792625/figures/llm-perf-pred.png

### 3.1 Algorithm 1 – UCB-E

The main limitation of the simple baseline is that in expectation it samples $\lfloor T/n\rfloor$ examples per method; evenly distributing its total budget across all different methods $f_{i}$. In order to distinguish the best method $f_{i^{*}}$ from other strong methods $f_{i}$ (i.e. $\mu_{i^{*}}-\mu_{i}$ is small), we may need more than $\lfloor T/n\rfloor$ examples, while $\leq\lfloor T/n\rfloor$ examples are sufficient to distinguish $f_{i^{*}}$ from obviously bad methods (i.e. $\mu_{i^{*}}-\mu_{i}$ is large).

We address this limitation by adaptive selecting example $t$ based on our previous $t-1$ observations until out budget $T$ is expended. Our first algorithm UCB-E ($\mathcal{A}_{\rm ue}$; Algorithm 1) is a simple extension of the classic multi-arm bandit algorithm UCB-E [].
For every method $f_{i}$, at every step $t$, we estimate the upper confidence bound,

$$ $B_{i}=\frac{\sum_{j=1}^{m}O_{ij}\cdot E^{\rm obs}_{ij}}{\sum_{j=1}^{m}O_{ij}}+ \sqrt{\frac{a}{\sum_{j=1}^{m}O_{i,j}}}.$ $$

In the subsequent iteration we pick the method $f_{i}$ with the largest upper confidence bound (ties are resolved by uniform random sampling), and then sample an example $x_{j}$ uniformly at random from the set of examples not yet observed, that is the set $\{j\in[m]|O_{ij}=0\}$. We run the inference procedure for $f_{i}(x_{j})$ and score the result, obtaining $E^{obs}_{ij}=e(f_{i}(x_{j}))$.

#### Comparison with the simple baseline.

The UCB-E algorithm efficiently addresses the limitations of the simple baseline by minimizing evaluations on suboptimal methods. For a bad method (i.e., when the gap $\mu_{i^{*}}-\mu_{i}$ is large), only a few evaluations (typically proportional to $\frac{1}{(\mu_{i^{*}}-\mu_{i})^{2}}$) are needed to ensure that its upper confidence bound will never exceed $\mu_{i^{*}}$. Consequently, the UCB-E algorithm will not select this method again, thus saving evaluation budget and focusing on more promising methods.

Figure: Algorithm 1 UCB-E ($\mathcal{A}_{\rm ue}(T,\mathcal{F},\mathcal{X};a)$)

#### Theoretical results.

We state the theoretical guarantee of UCB-E in our context, which is a corollary of the theorem for UCB-E in the original multi-arm bandit setting [].

###### Corollary 1 (Lower bound on success probability of UCB-E)

Define $H_{1}=\sum_{i=1,i\neq i^{*}}^{n}\frac{1}{(\mu_{i}-\mu_{i}^{*})^{2}}$ and suppose $a=\frac{25}{36}\frac{T-n}{H_{1}}$, $\mathbb{P}_{\mathcal{A}_{\rm ue}}(\mathcal{A}_{\rm ue}(T,\mathcal{F},\mathcal{
X};a)=i^{*})\geq 1-2Tn\exp\left(-\frac{T-n}{18H_{1}}\right)$.

Comment. $H_{1}$ in the corollary indicates the hardness of the problem specified by $(\mathcal{F},\mathcal{X},e)$. The larger the gaps between the highest and all other scores are, the higher the probability that UCB-E will pick the best method given a fixed budget $T$. In our experiments, we will observe that the datasets with smaller $H_{1}$ tend to have a higher chance of predicting $i^{*}$ correctly, given the same evaluation budget $T$.

###### Corollary 1 (Lower bound on success probability of UCB-E)

### 3.2 Algorithm 2 – UCB-E with Low-Rank Factorization (UCB-E-LRF)

Algorithm 1, the UCB-E algorithm, treats each method independently and samples examples for a method uniformly at random. In practice, however, methods and examples are correlated with each other and we can predict the outcome of a particular method-example pair from previous observations. Being able to accurately predict the outcome gives better estimate of the score of a method. Additionally, instead of sampling examples uniformly at random, prioritizing examples with large prediction uncertainties reduces the overall uncertainty in the scores of each method, which provides more accurate score estimates in the subsequent steps. In this section, we propose a low-rank factorization based algorithm (UCB-E-LRF) to capture the above intuition.

#### Low-rank factorization.

A natural approach to modeling these method-example interactions is through low-rank matrix factorization. Intuitively, if the method-examples are very correlated, there should exist $U\in\mathbb{R}^{n\times r}$ and $V\in\mathbb{R}^{m\times r}$ and rank $r\ll\min(n,m)$ such that $E\approx UV^{\top}$. Obtaining $U$ and $V$ from observed scoring matrix $E^{\rm obs}$ allows us to
estimate the scores of all method-example pairs from just a few scores.
For instance, if the matrix $E$ were an exact rank-1 matrix, only $n+m-1$ scores would be needed to recover the full scoring matrix $E$, which is far more efficient than exhaustively evaluating all $n\times m$ combinations.
To find $U$ and $V$, we use alternating least squares [] to optimize the following problem:

$$ $\min_{U,V}\Big{|}\Big{|}O\odot\Big{(}UV^{T}-E^{\rm obs}\Big{)}\Big{|}\Big{|}_{ F}^{2}.$ (1) $$

#### Score estimation.

We can then combine the observed matrix $E^{\rm obs}$ and estimated matrix $\hat{E}=UV^{T}$, using $O$ as a gating function, to arrive at a prediction of the score $\mu_{i}$ as follows:

$$ $\hat{\mu}_{i}=\frac{1}{m}\sum_{j=1}^{m}O_{i,j}E^{\rm obs}_{i,j}+(1-O_{i,j}) \hat{E}_{i,j}.$ (2) $$

#### Uncertainty estimation.

The score estimation gives us a better way to estimate score of every method by exploiting the correlation between methods and examples at every step. We now discuss how we estimate prediction uncertainties with ensembles.

By ensembling the factorization model, we obtain an empirical distribution of predictions for each method-example pair. Consequently, the standard deviation of the predictions can be used to quantify uncertainty. If the predictions are very similar to each other, this suggests the ensembles tend to agree with each other, and hence there is little uncertainty.
In order to achieve sufficient model variance to approximate uncertainty, we uniformly at random drop some values from $E^{\rm obs}$ when solving the factorization problem in Equation 1 for each model  [, ]. For an ensemble of size $S$ the estimate for $\hat{E}$ becomes the following:

$$ $\hat{E}=\frac{1}{S}\sum_{s=1}^{S}U^{(s)}(V^{(s)})^{T}.$ (3) $$

Then the uncertainty matrix $R\in\mathbb{R}^{n\times m}$ is given by:

$$ $R=\sqrt{\frac{1}{S}\sum_{s=1}^{S}\Bigg{[}\Big{(}1-O\Big{)}\odot\Big{(}U^{(s)}( V^{(s)})^{T}-\hat{E}\Big{)}\Bigg{]}^{2}}.$ (4) $$

#### Adapative selection.

Bringing score estimation and uncertainty estimation together, we propose our second algorithm UCB-E-LRF ($\mathcal{A}_{\rm uel}$; Algorithm 2), an extension of Algorithm 1 leveraging the low-rank factorization model $\mathcal{M}$. The high level structure of the algorithms are very similar to each other. Specifically, we estimate the upper confidence bound (UCB) for each method based on a linear combination of score and uncertainty estimation, select the method with the greatest UCB, and evaluate the method on an example that has the highest uncertainty. Lastly, we introduce a warm-up budget $T_{0}$. This is because $\mathcal{M}$ requires a minimum number of initial observations in order to estimate the low-rank representation accurately.
Therefore, before the active selection phase (line 3-9 in Algorithm 2), we have a warm-up phase (line 1-2 in Algorithm 2), where $T_{0}$ method-example pairs are sample uniformly at random to evaluate before moving on to the “active" phase.

Figure: Algorithm 2 UCB-E-LRF ($\mathcal{A}_{\rm uel}(T,\mathcal{F},\mathcal{X};\mathcal{M},r,S,T_{0},\eta)$)

## 4 Experiments

In this section, we study the performance of UCB-E and UCB-E-LRF in a variety of real settings. We begin by describing our dataset and metrics, and then analyze the experimental results and ablations.

Figure: Figure 3: Comparison of baselines and our proposed algorithms on six datasets evaluated with various top 1 precision and NDCG@10. The vertical axes of all plots represent performance of a metric and horizontal axies of all plots represent the percentage of method-example pairs evaluated. All results are aggregated based on 50 trials with different random seeds. Our proposed algorithms: UCB-E and UCB-E-LRF consistently require much less evaluation to achieve the same performance as baselines.
Refer to caption: extracted/5792625/figures/main.png

Figure: Figure 4: Ablations of the proposed algorithms and hyperparameters. UCB-E and UCB-E-LRF are denoted by blue and red lines, respectively, consistent with Figure 3.
Refer to caption: extracted/5792625/figures/ablation.png

### 4.1 Datasets

To assess the performance of our algorithms under a variety of use cases, we test with three datasets AlpacaEval [], *Grade School Math 8K (GSM8K)* [] and *Physical Interaction: Question Answering (PIQA)* [], together with different settings of the method set $\mathcal{F}$ and the scoring function $e$; Table 2 summarizes the statistics of each dataset along with what *method* $\mathcal{F}$ and *scoring function* $e$.
For AlpacaEval, we design two sets of $\mathcal{F}$. The first set $\mathcal{F}$ contains all LLMs reported by
[]. The second $\mathcal{F}$ contains the same LLMs except for the annotator model GPT-4 Turbo.
The latter $\mathcal{F}$ that does not contain GPT-4 Turbo makes the learning more challenging and interesting since the annotator, GPT-4 Turbo, is a clear winner among all LLMs.
For GSM8K and PIQA, we set $\mathcal{F}$ as a set of prompts to simulate prompt engineering, or a set of LLMs with various sampling configurations, to mimic model selection and hyperparameter tuning.
We provide more information about these datasets in Appendix A.

**Table 2: Statistics of each dataset used in our experiments. The examples $\mathcal{X}$ of each dataset are the questions from their respective evaluation benchmark. More details of the datasets can be found in Appendix A.**
| Dataset Name | Size $n\times m$ | Method $\mathcal{F}$ | Scoring Function $e$ | $H_{1}$ |
| --- | --- | --- | --- | --- |
| AlpacaEval | $154\times 805$ | Various LLMs | GPT4-turbo annotator | 966 |
| AlpacaEval (Drop Annotator) | $153\times 805$ | Various LLMs excluding GPT4-turbo | GPT4-turbo annotator | 4462 |
| GSM8K Prompts | $205\times 784$ | Mistral-7B [] with different prompts | regex match with correct answer | 107445 |
| GSM8K Models | $122\times 1000$ | Various LLMs and sampling configurations | regex match with correct answer | 20562 |
| PIQA Prompts | $177\times 1546$ | Tulu-7B [] with different prompts | regex match with correct choice | 66284 |
| PIQA Models | $103\times 1000$ | Various LLMs and sampling configurations | regex match with correct choice | 10273 |

### 4.2 Metrics

#### Top 1 Precision.

To determine if an algorithm finds the best method, we can directly check if the algorithm’s prediction matches with the best method from our empirical data. However, because every method is empirically evaluated on limited number of examples, it is possible that one method has slightly lower average performance than another method whereas if we were to evaluate on more examples, the former would achieve a higher performance. To this end, we calculate top 1 precision by first determining a set of methods we consider equally good and we check if the predicted method from an algorithm is a member of that set. We propose two ways to determine if a set of methods are equally good: performance gap and statistical significance. For performance gap $\epsilon$ top 1 precision, we consider all methods whose performance is within $\epsilon$ of the best empirical method to be equally good. For the statistical significance $p$ top 1 precision, we perform McNemar’s statistical test [] for each method against the best empirical method. If we cannot reject the null hypothesis that the performance of one method is the same as the best empirical method up to a significance level $p$, then that method is considered equally good as the best method. We evaluate all baselines and our algorithms on two $\epsilon$ values $\{0.001,0.01\}$, and two $p$ values $\{0.01,0.1\}$ simulating a diverse need of precision.

#### NDCG@K.

Although our focus is to identify the best method quickly, it is sometimes also desirable to generally rank top K promising methods high. We therefore evaluate with normalized discounted cumulative gain (NDCG) at K. NDCG@K takes as input the top K prediction by an algorithm and the higher their true ranks are, the higher the NDCG is. We choose $K=10$ to evaluate all algorithms.

### 4.3 Set-Up of Our algorithms and Baselines

We introduce the set-up of our two algorithms, UCB-E and UCB-LRF, together with three baselines, Row Mean Imputation, Filled Subset and LRF.

#### UCB-E.

Our proposed algorithm as shown in Algorithm 1. We use $a=1$ since this consistently yields the best performance across all datasets. This parameter is ablated in Figure 7 of Appendix B.

#### UCB-E-LRF.

Our proposed algorithm as shown in Algorithm 2. For all datasets, we use rank $r=1$ for low rank factorization with an ensemble size of $S=64$. We use $5\%$ of data for warm up i.e. $T_{0}=0.05\times n\times m$ and $\eta=5$.

#### Row Mean Imputation.

In this baseline, we select method-example pairs uniformly at random from all pairs. The score for each method is calculated as the average of all the scores evaluated so far for that method. The detailed algorithmic description is in Algorithm 3.

#### Filled Subset.

Instead of randomly selecting method-example pairs, filled subset first selects an example index $j$ uniformly at random. Then all methods are evaluated on example $j$. If all methods have been evaluated, the algorithm selects a new example index from remaining ones. The score for each method is calculated as the average of all the scores evaluated so far for that method. The detailed algorithmic description is in Algorithm 4. Although row mean imputation and filled subset do not have learning component, they both produce an unbiased estimate of the real score for each method at all time.

#### LRF.

Similar to row mean imputation, LRF (low rank factorization) randomly selects method-example pairs to evaluate. For estimating the score of each method, LRF calculates the average of all scores for that method. That is, for evaluated examples, the score is the actual observed score, and for examples yet to be evaluated, the score is the estimated score from LRF. The detailed algorithmic description is in Algorithm 5.

Finally, for better practicality and efficiency, all algorithms and baselines are implemented with a batch size $b$. That is, instead of selecting and evaluating just one example at a time, the algorithms select $b$ examples. For algorithms that involve randomly drawing an example, they are modified to randomly drawing $b$ examples without replacement. For algorithms that draw an example with the $\arg\max$ operator, they are modified to drawing with the $\mathrm{Top-}b$ operator. We use $b=32$ for reporting all main results.

### 4.4 Main Results

In Figure 3, we plot the performance of baselines and our algorithms on all six datasets (columns) as the budget $T$ increases from 5% to 100% of the total number of method-example pairs.
In each row, we evaluate the algorithms on a different metric (either top 1 precision with different $\epsilon$, $p$ or NDCG@10).
Each line in the figure is the average result over 50 independent trials with different seeds.
For example, an average top 1 precision of 0.9 indicates that 45 out of 50 trials predict the best method correctly at the budget level that its x-coordinate represents.
In addition, we calculate $H_{1}$ as defined in Corollary 1 that quantifies the difficulty of finding the best method on a dataset. Intuitively, a higher $H_{1}$ value suggests that the method set $\mathcal{F}$ is large or there are many methods that have similar performance with the best one and distinguishing them can be challenging.
In Appendix A Figure 5, we also plot the histogram to show the distribution of performance among $\mathcal{F}$ on these datasets.

#### How do our algorithms compare with the baselines?

As seen from Figure 3, both UCB-E and UCB-E-LRF consistently achieve high precision and NDCG with much less budget compared to the baselines.
For example, on AlpacaEval (Drop Annotator), our proposed algorithms can reach precision of 1 with just 8% budget whereas the baselines require 80-90%, an order of magnitude more budget needed.
These results suggest that it is entirely possible to identify the best method without exhaustively evaluating all method-example pairs.
They further demonstrate that the active selection algorithms (our two algorithms) are more efficient than the non-active algorithms (three baselines).
Additionally, the better NDCG performance from our proposed algorithms shows that our methods can more correctly rank top-performance methods.

#### How is the comparison between our two algorithms UCB-E and UCB-E-LRF?

The datasets from left to right are ranked by the hardness indicated by $H_{1}$.
Interestingly, we find that on easier datasets such as AlpacaEval, UCB-E performs better and saves 2-3% more on budget compared to UCB-E-LRF, while on harder datasets, such as GSM8K Prompts and PIQA Prompts, UCB-E-LRF achieves higher precision faster than UCB-E, saving about 10% in absolute budget.
These observations give us a hint on what algorithm to apply in practice.

### 4.5 More Empirical Analysis

We provide more empirical analysis and the ablation results can be found in Figure 4.

#### Does H 1 subscript 𝐻 1 H_{1} italic_H start_POSTSUBSCRIPT 1 end_POSTSUBSCRIPT correctly reflect the hardness of a dataset in the empirical experiments?

Yes, going through Figure 3 from left to right, as $H_{1}$ decreases, the percentage of matrix evaluation needed to reach precision of 1 also generally decreases from more than 20% to just under 5%. Moreover, the $H_{1}$ values seem to be related to the tasks. That is, prompt engineering datasets typically have higher $H_{1}$ possibly due to the homogeneity of prompt performance with the same LLM. In contrast, datasets that benchmark different LLMs such as AlpacaEval is much easier to find the best performing model.

#### Score Only Ablation.

To study the effect of selecting both the next method and the next example to evaluate using the uncertainty matrix $R$, we consider an ablation of UCB-E-LRF. In this variant, called UCB-E-LRF (Score Only), we modify the UCB-E algorithm by replacing its mean calculation with the mean calculated via low-rank factorization (as described in Equation 3). The upper confidence bound calculation and next example selection is the same as the original UCB-E algorithm.

The detailed algorithmic description can be found in Algorithm 6.
We see that on the hard dataset GSM8K Prompts where UCB-E-LRF has certain benefit over UCB-E, there is a significant gap between UCB-E-LRF and UCB-E-LRF (Score Only).
This means that the component of uncertainty matrix $R$ in UCB-E-LRF is crucial to contribute the benefit over UBC-E.

#### Batch Size b 𝑏 b italic_b Ablation.

Intuitively, a smaller batch size is more flexible can have more fine grained selection. We experiment with $b\in\{1,32,128\}$ and as shown in the plot, smallest batch size gives the best performance especially on harder datasets whereas a batch size of 128 significantly degrades the performance.
However, it incurs more overall computational cost due to fitting low rank factorization more often than a smaller batch size; for example when $b=2$, it takes almost 16 times as much time as $b=32$ to achieve $1.0$ precision, which is ineffective.

#### Ensemble Size S 𝑆 S italic_S Ablation.

We vary the ensemble size $S\in\{4,16,64,256\}$ and find that very small ensemble size gives suboptimal performance on hard datasets. There is almost no performance difference on easy dataset like AlpacaEval (Drop Annotator).
The performance is robust to different $S$ as long as it is larger than $64$.

#### Uncertainty Scaling Factor η 𝜂 \eta italic_η Ablation.

We experiment with different uncertainty scaling values $\{0.1,0.5,1,5,10\}$. In Figure 4d,
it can be seen that a certain range of $\eta$, from $0.1$ to $5$, gives similar performance on both two datasets.
This demonstrate the robustness of selecting $\eta$.

#### Warm-up Budget T 0 subscript 𝑇 0 T_{0} italic_T start_POSTSUBSCRIPT 0 end_POSTSUBSCRIPT Ablation.

Our algorithm UCB-E-LRF by default randomly evaluates $5\%$ of the method-example pairs in the data matrix before actively selects. We analyze the effect of varying the budget $T_{0}$ among $\{0.5\%,1\%,5\%,10\%\}\times n\times m$ on the algorithm performance on the two datasets. We see that a very small warm-up budget with $0.5\%$ of data can achieve decent precision initially, but fall behind compared to larger warm-up budget as more data are evaluated. In contrast, a very large warm-up budget of $10\%$ delays the active selection algorithm too much and also achieves suboptimal performance. We therefore use $5\%$ as a generally strong starting point. Note that on AlpacaEval, it is possible to achieve the same performance with even smaller warm-up budget, suggesting more saving is possible.

#### Rank r 𝑟 r italic_r Ablation.

Hyperparameter $r$ adjusts the bias-variance trade-off. Empirically we experiment with $r\in\{1,2,5\}$ and find that $r=1$ is consistently better than larger value counterparts. The results can be explained by the fact that a larger $r$ requires more evaluated data in order to prevent overfitting, which might not have advantage in the limited budget setting. Therefore, we recommend using $r=1$ for all datasets.

## 5 Related Work

#### Best-arm identification in multi-arm bandits.

The goal of best-arm identification [, ] is to find the arm with the highest reward by pulling these arms and getting the feedback. By making an analogy, in our problem method $f_{i}$ is the arm and the score $\mu_{i}$ of $f_{i}$ is the reward. There are two ways to define the best-arm identification problem: fixed budget and fixed confidence.
In the fixed budget setting, the budget for the arm pulls is fixed and the algorithm is designed for better chances to identify the correct best arm – our problem defined in this paper has the similar evaluation budget.
UCB-E [] and Successive Elimination [] are two pioneering algorithms proposed for this setting, followed by a line of improvement [, , , ]. Qin [] states the optimal fixed budget best-arm identification as an open problem.
In the setting of fixed confidence, the algorithms [, , ] work towards fewer number of arms to guarantee the given confidence of getting the best arm.
Garivier and Kaufmann [] gives an optimal algorithm in terms of the minimum of arms to pull.
Another extension beyond the setting of fixed budget or confidence is the PAC learning framework, where the target is to maximize the chance of getting an *mostly* best arm, with a tolerance of $\varepsilon$ gap to the highest reward [, , ].

#### LLM evaluation with multi-arm bandits.

Concurrently, Shi et al. [] explores using multi-arm bandit for prompt optimization in a limited budget setting. Our work does not solely focus on prompt optimization and instead a more general evaluation setup. We also propose an algorithm that leverages low-rank factorization for better best-arm identification performance.

#### Low-rank factorization for (noisy) matrix completion.

As shown in the objective function of Equation 1, low-rank factorization is a non-convex optimization problem. Therefore a line of work focus on how to solve this non-convex optimization [, , ], while another line of work [, ] study the approximation error between the estimated low-rank matrix and the target matrix in terms of $p$ when assuming the observations are i.i.d. sampled with a pre-assumed chance $p$ and the additive noise to each observation is i.i.d. Gaussian noise.

#### LLM performance evaluation functions.

Tremendous effort has been devoted to developing effective evaluation functions to assess the quality of open-ended generations from language models. Early work in this direction such as BLEU [] and ROUGE [] are rule-based that use lexical overlaps to quantify similarity between a generated response and reference. However, lexical overlaps may not align well with the underlying semantics of the text. The shortcomings of these rule-based evaluation functions motivated a line of work studying using language models [, , ] to evaluate generations. A seminal work in this area is BERTScore which uses embeddings from a BERT model [] to compute similarity. More recently, LLM-as-a-Judge [] proposes using instruction-tuned large language models to evaluate generations. Zheng et al. [] finds that costly proprietary models such as GPT4 have high agreement rate with human.

#### LLM performance evaluation benchmarks.

Diverse benchmarks have been developed to evaluate LLM performance across various domains including natural language understanding on translations and sentiment analysis [, , ], mathematical and common sense reasoning [, , ], text retrieval and question answering [, , ]. We refer readers to [] for a more comprehensive discussion on existing benchmarks. The commonality of these benchmarks is that a ground truth answer is typically given and once the responses from LLMs are generated, they can be evaluated fairly efficiently without incurring large amount of overhead such as money and compute. Recently, a new type of benchmark or more precisely leaderboard has been created attempting to compare various LLMs to each other. The typical setup involves providing the same prompt to two LLMs and then having their responses compared side by side with another LLM, which determines which response is considered superior and thus wins. Two notable leaderboards are AlpacaEval [] and Chatbot Arena []. AlpacaEval has a static prompt dataset and for each prompt and LLM, the response is compared with that of a baseline model (GPT3 or GPT4). For Chatbot Arena, the prompts are submitted by users and two random LLMs are selected to respond to the user-written prompt. For both benchmarks, to aggregate the overall performance of LLMs, average win rate or ELO score can be calculated from the pairwise comparison statistics. Since the evaluation requires using another LLM to decide the better response, the evaluation incurs additional compute and / or monetary cost than the benchmarks that evaluate models based on ground truth answers.

## 6 Discussion and Conclusion

One limitation of our proposed algorithms is that we assume there is a two-dimensional fixed-size matrix as our dataset for active method-example selection. In some real-world applications, new rows or columns can be gradually incorporated and the matrix size is dynamic. In other scenarios such as Chatbot Arena, instead of being able to decide what examples to select, we can only select a pair of models to compare for a user-specified example. We leave studying how to minimize budget to find the best method for these new settings as future work.

In this work we focus on identifying the top-performer with limited budget as it is a very common problem; covering a wide range of applications particularly for practitioners who simply want to find the best prompt or model for deployment purposes. Another interesting direction for future work is recovering a full or top K ranking of performers, as it provides more fine-grained information that is necessary for specific use cases such as iterating on LLM design, and tracking LLM ranking over time. Of course in this setting the opportunity for resource savings is less than in the top-performer setting. In Figure 3, we evaluate our algorithms on NDCG@K as preliminary evidence supporting the possibility of resource saving recovering a top K ranking. We leave a more thorough study for future work.

In conclusion, we formulate the problem that when the evaluation for each model-example is resource intensive in regard to money, compute and time, given a certain budget of resource, how can we still have a high probability of identifying the best model on a specific dataset among a set of candidates. We propose two algorithms to tackle the problem, which all sequentially decide which model-example pair to evaluate next by observing the previous evaluated pairs. The first algorithm follows the idea of a classic multi-arm bandit algorithm UCB-E and enjoys the similar theoretical guarantee to lower bound the chance given any budget. The second algorithm, UCB-E-LRF extends UCB-E by leveraging the finding of approximate low-rank of the target evaluation matrix. In the experiment, we show that both algorithms introduced in our paper are significantly better than one that just uniformly samples method-example pairs. Moreover, we identified the condition when the UCB-E or UCB-E-LRF works better than the other. We do not foresee any negative societal impacts for our work.

## 7 Acknowledgement

We thank Justin Lovelace, Varsha Kishore, and Katie Luo for their helpful discussion and feedback on the paper draft. JPZ is supported by a grant from the Natural Sciences and Engineering Research Council of Canada (NSERC) (567916). CKB and CPG are supported by the Cornell University AI for Science Institute, the AI Climate Institute, the National Science Foundation, the National Institute of Food and Agriculture, and the Air Force Office of Scientific Research. RW is supported by grants from National Science Foundation NSF (CIF-2402817, CNS-1804829), SaTC-2241100, CCF-2217058, ARO-MURI (W911NF2110317), and ONR under N00014-24-1-2304. Wen Sun is supported by NSF IIS-2154711 and NSF CAREER 2339395. This research is also supported by grants from the National Science Foundation NSF (IIS-2107161, and IIS-1724282, HDR-2118310), the Cornell Center for Materials Research with funding from the NSF MRSEC program (DMR-1719875), DARPA, arXiv, LinkedIn, and the New York Presbyterian Hospital.

## Appendix A Additional Details - Datasets

Figure: Figure 5: Bar plot of model performance on all examples in all six datasets. Examples are ordered by their rank. Dataset $H_{1}$ values are displayed next to dataset name. It can be seen that datasets, such as AlpacaEval, that have a large gap between the best and second best method have small $H_{1}$ values. The $H1$ value indicates the difficulty of identifying the best method with smaller values indicating easier identification.
Refer to caption: extracted/5792625/figures/data_distributions.png

#### AlpacaEval and AlpacaEval (Drop Annotator).

AlpacaEval benchmarks various models on a fixed set of 805 questions. First, for each model, the responses to these questions are collected. Then, each response is compared against that of a baseline model (GPT4-turbo) by using an LLM judge (in this case, GPT4-turbo as well). We collected the AlpacaEval dataset on May 20, 2024 from the official repository (^1^11https://github.com/tatsu-lab/alpaca_eval). At that time, there were in total 154 models benchmarked, and hence our dataset size is $154\times 805$. To remove the bias of favoring its own responses, we also create a derived dataset called AlpacaEval (Drop Annotator) where we drop the responses of the annotator model, which leads to a size of $153\times 805$.

#### GSM8K Prompts and PIQA Prompts.

To simulate a prompt engineering use case, we create two datasets: GSM8K Prompts and PIQA Prompts. For these datasets, we ask GPT4 to generate 205 and 177 prompts following the prompt engineering work from Yang et al. []. The LLM used to perform inference on the datasets are Mistra-7B [] and Tulu-7B [] respectively. We evaluate the prompts on 784 and 1546 questions on the training set (about 10% of the size of the two training sets). For scoring, we extract the final answers from the responses generated by the LLMs and compare them with the ground truth answers (for GSM8K) or ground truth choice (for PIQA).

#### GSM8K Models and PIQA Models.

Lastly, for the model selection and hyperparameter tuning use case, we similarly create two more datasets on GSM8K and PIQA. Instead of each method being a prompt, each method is now a combination of LLM with different sampling configurations. Specifically, we use 11 public available models: GPT2 (^2^22https://huggingface.co/openai-community/gpt2), GPT2-Large (^3^33https://huggingface.co/openai-community/gpt2-large), CodeLLaMA (^4^44https://huggingface.co/codellama/CodeLlama-7b-python-hf), Tulu-7B (^5^55https://huggingface.co/TheBloke/tulu-7B-fp16), Tulu-2-7B (^6^66https://huggingface.co/allenai/tulu-2-7b), Gemma-7B (^7^77https://huggingface.co/google/gemma-7b), Phi2 (^8^88https://huggingface.co/microsoft/phi-2), Llema-7B (^9^99https://huggingface.co/EleutherAI/llemma_7b), LLaMA-2-7B (^10^1010https://huggingface.co/meta-llama/Llama-2-7b-chat-hf), Mistral-7B (^11^1111https://huggingface.co/mistralai/Mistral-7B-v0.1) and StarCoder-7B (^12^1212https://huggingface.co/bigcode/starcoder2-7b). We also have three temperature choices $\{0,0.5,1\}$, two maximum decoding length choices $\{128,512\}$ and two zero-shot prompt choices (directly asking for the answer and Let’s think step by step). The Cartesian product of all these choices give in total 132 different combinations as our methods. Depending on the dataset, some of these configurations experienced out-of-memory error on a Nvidia 3090 when we collected our data which we drop to simulate real-world scenarios. For the examples, we randomly select 1000 questions from each dataset.

**Table 3: Ratio of the largest to second largest eigenvalue.**
| Dataset Name | GSM8K Prompts | PIQA Prompts | GSM8K Models | PIQA Models | AlpacaEval (Drop Annotator) | AlpacaEval |
| --- | --- | --- | --- | --- | --- | --- |
| $\frac{\lambda_{1}(E)}{\lambda_{2}(E)}$ | 6.0729 | 11.2547 | 3.0048 | 5.0712 | 2.8573 | 2.7316 |

Figure: Figure 6: Bar plot of the explained variance of each principal component for all six datasets.
Refer to caption: extracted/5792625/figures/explained_variance.png

## Appendix B Additional Details - Algorithms

The algorithms for Row Mean Imputation, Filled Subset, LRF and UCB-E-LRF (Score Only) are shown in Algorithm 3, 4, 5 and 6 respectively.

Figure: Figure 7: Ablation of the exploration parameter $a$ of UCB-E, Algorithm 1.
Refer to caption: extracted/5792625/figures/ucbe_exploration.png

Figure: Algorithm 3 Row Mean Imputation ($\mathcal{A}_{rmi}(T,\mathcal{F},\mathcal{X})$)

Figure: Algorithm 4 Filled Subset ($\mathcal{A}_{fs}(T,\mathcal{F},\mathcal{X})$)

Figure: Algorithm 5 LRF ($\mathcal{A}_{lrf}(T,\mathcal{F},\mathcal{X};\mathcal{M},r,S,T_{0})$)

Figure: Algorithm 6 UCB-E-LRF (Score Only) ($\mathcal{A}_{uel-so}(T,\mathcal{F},\mathcal{X};\mathcal{M},r,S,T_{0},\eta)$)

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 10
presentation: 4
questions: -	Line 186: by adaptive selecting --> by adaptively selecting
-	Proof reading is needed to fix typos. 
-	What does a stand for in equation in line 190?
-	I suggest some table/mapping to keep track of the different notions used and their meaning.
soundness: 4
strengths: -	The proposed algorithms can be used for a variety of evaluation use cases, not limited to LLMs.
-	The paper provides enough and clear description of relevant concepts on which the proposed solution is built.
-	The paper is very well-written.
-	The proposed approaches show great money and time reduction on large evaluation datasets. 
-	The approach was evaluated on variety of tasks, setups, methods, and was evaluated using a thoughtful evaluation approach.
summary: The paper proposes two active selection algorithms for evaluation based on the classical approach of estimation of the upper confidence bound. The main aim of the proposed algorithms is to identify the best performing method across a set of validation examples, given a fixed evaluation budget. The budget can be monetary cost or GPU time. The methods to evaluate can be different prompts or hyperparameter settings.
weaknesses: -	Nothing major to report here

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: In the experimental setup, the authors set the rank r = 1or UCB-E-LRF. Although the ablation study shows that r=1 achieves the best performance, this choice appears overly low compared to related research. The authors should provide more evidence to demonstrate that this is not due to sampling error or an inadequately small dataset.
soundness: 3
strengths: The paper introduces UCB-E and its variant UCB-E-LRF. 

The authors conducted extensive experiments across multiple datasets and performed repeated random seeds, which enhance the stability of the results.
summary: This paper investigates the evaluation problem of large language models (LLMs) and proposes a UCB-based evaluation method that can identify the optimal LLM strategy for a specific task with a lower budget.
weaknesses: - Some descriptions in the paper are unclear. For instance, Figure 3, which presents key experimental results, lacks a legend, making it difficult to interpret. 

- Additionally, the paper does not clearly define the baseline methods used in the experiments. 

- Some results also lack in-depth discussion. For example, Figure 3 shows that UCB-E and UCB-E-LRF perform inconsistently across different datasets. The authors attribute this to varying dataset difficulty; however, when comparing dataset pairs like (GSM8K Models, PIQA Models) and (GSM8K Prompts, PIQA Prompts), the conclusions are contradictory. More detailed explanation and discussion from the authors are needed here.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: In the whole paper, only one baseline is described: uniformly sample and evaluate T examples, but three baselines are mentioned later on, and shown in the figures. What are the two other baselines? Can they be given some attention in the paper?

I have multiple small suggestions to improve the clarity and readability of the paper:
- In Table 2, the H1 value for each dataset is stated. But there is no explanation of what a higher or lower value means in the caption, or anywhere near where the table is cited. I had to refer to the Corollary 1 where it is mentioned, re-read to figure out what a higher or lower value means, to later find an explanation in section 4.4. 
- In Table 2, the columns are ordered: “Dataset Name”, “Size m x n”, “Method Set”. The size is m x n, m stands for methods, n for data samples. I would either swap the “Dataset Name” and “Method Set” columns, or transform the “Size m x n” column to “Size n x m” to have a natural ordering of the columns and the order of the sizes.
- In Figure 3, there is no legend for the curve colors. In the caption of Figure 4 it is stated that the UCB-E and UBC-E-LRF are blue and red (at least for Figure 4), but there is no mention of the other curves anywhere.
- Figure 3 has the datasets ordered from highest H to lowest, and it is mentioned in 4.4 (2 pages forward) that they are ordered by hardness. There is no mention that they are ordered from hardest to easiest, and that higher H means harder and lower H means easier. It can be deducted from the whole text, but it is not immediately obvious.
soundness: 3
strengths: - To the best of my knowledge, this is the first paper to be using the multi-armed bandit for LLM model/setup evaluation.
- The idea is solid, and useful. Especially, with the ever growing number of models, size of models and knobs that you can tweak to improve the performance for a specific/custom task. This framework can substantially reduce resources when practitioners have to choose a best model for their use-case.
- The algorithms are clearly outlined, making the understanding and reproduction easy.
- A big strength is that the experiments are done on multiple datasets, with varying H1. This paints a clear picture of how this framework works in different setups, and which one (UCB-E or UCB-E-LRF) to choose for which setup.
The ablations are extensive: ensemble size, uncertainty scaling factor, warm-up budget, rank, etc.
summary: This paper proposes and extends the well-known multi-armed bandit (UBC) for selection of a best method/setup given a set of method (for example: an LLM, prompt, decoding parameters), a scoring function (for example: exact string matching, BLEU, ROGUE, LLM based annotator) and dataset of examples to evaluate the methods on. This extended multi-arm bandit is referred to as UBC-E. Furthermore, the paper proposes to incorporate a low-rank factorization of the observed scores to enable it to reliably interpolate missing evaluation scores. The low-rank factorization leverages the fact that method-examples are correlated with each other. The whole UBC-E-LRF conserves resources while still guaranteeing confidence that the best method/setup will be chosen.


All this is supported by theoretical proof and discussions, and furthermore shown by empirical experiments on three datasets, and various methods and setups. The UBC-E and UBC-E-LRF are compared with baselines, the top-1 precision and NDCG@10 are used as metrics.
weaknesses: - In section 3.2, low-rank factorization: “Intuitively, if the method-examples are vert correlated, there should exist….” while I do agree with the intuition, it would be nice to have a citation here. At least the citation from the appendix: “Chen et al., 2020; Cai et al., 2019”.
- Even though the information is in the paper, it requires going back and forth to find it. For example, the figure captions are lacing information that is present elsewhere in the text, or not present at all. Some redundancy in the text for the sake of clarity is always welcome. I added suggestions to improve this in the Question section below.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: See the weakness
soundness: 2
strengths: (1) The studied task is interesting. 
(2) The proposed method seems to be effective in acclerating the evaluation.
summary: This paper proposes an adaptive approach that exploits the fact that few samples can identify superior or inferior settings and many evaluations are correlated. It uses multi-armed bandits to identify the next (method, validation sample)-pair and low-rank matrix factorization to fill in missing evaluations.
weaknesses: (1) The paper seems to be recycled and revised from a longer sumbisison, and many parts (especially figures or tables) are with tiny fonts, which are difficult to read.

(2) Some experimental results are difficult to understand, e.g., Table 3.

(3) Overall, I believe evaluation is quite important, and it often involves a number of influencing factors. What if there exists biases in the test datasets? How the comparison results are consistent with human evaluation, since automatic evaluation may not reflect the real capacities of LLMs? 

(4) The related work part is weak, which needs more discussions on evaluation of LLMs.

Meta-review: The paper presents an approach to evaluate multiple language models across a set of tasks, given a fixed evaluation budget. The idea is to expend this budget intelligently so as to quickly identify the best performing models, and not spend it on models that perform poorly. This is achieved by applying a multi-armed bandit algorithm, coupled with a low-rank estimator of the (LLM, task) score matrix.

Reviewers were unanimously supportive of the paper, finding it to be an interesting application of multi-armed bandits to a topical problem. From the AC's reading, the technical novelty may be a little restricted, but the the paper indeed executes the presented ideas well, and the work could be of broad interest to the community. The authors are encouraged to consider reporting results on a larger pool of datasets, which could further convince of the value of the proposed framework.

Decision: Accept (Poster)