Better Instruction-Following Through Minimum Bayes Risk

## Abstract

Abstract General-purpose LLM judges capable of human-level evaluation provide not only a scalable and accurate way of evaluating instruction-following LLMs but also new avenues for supervising and improving their performance. One promising way of leveraging LLM judges for supervision is through Minimum Bayes Risk (MBR) decoding, which uses a reference-based evaluator to select a high-quality output from amongst a set of candidate outputs. In the first part of this work, we explore using MBR decoding as a method for improving the test-time performance of instruction-following LLMs. We find that MBR decoding with reference-based LLM judges substantially improves over greedy decoding, best-of-N decoding with reference-free judges and MBR decoding with lexical and embedding-based metrics on AlpacaEval and MT-Bench. These gains are consistent across LLMs with up to 70B parameters, demonstrating that smaller LLM judges can be used to supervise much larger LLMs. Then, seeking to retain the improvements from MBR decoding while mitigating additional test-time costs, we explore iterative self-training on MBR-decoded outputs. We find that self-training using Direct Preference Optimisation leads to significant performance gains, such that the self-trained models with greedy decoding generally match and sometimes exceed the performance of their base models with MBR decoding.

## 1 Introduction

Instruction-following large language models (LLMs) (Chung et al., ; Wei et al., ) have shown remarkable potential as generalist problem-solvers, prompting extensive efforts to improve their performance. One task that has seen tremendous progress due to LLMs is the evaluation of text generation itself. Recent works find that “LLM-as-a-Judge” frameworks (Zheng et al., ; Li et al., ; Dubois et al., ) demonstrate strong correlation with human evaluations and significantly outperform lexical (Lin, ; Papineni et al., ) and embedding-based methods (; Yuan et al., ; Qin et al., ) across a wide range of instruction-following tasks.

While the use of LLM judges has largely focused on the evaluation of outputs, LLM judges can also provide a way to supervise the generations of other LLMs.
This generally involves using the judge as a *reference-free* evaluator to score candidate outputs produced by the LLM and then selecting the highest-scoring candidate as the final output in what is known as best-of-N (BoN) decoding (Song et al., ).
However, prior works find that LLM judges, including powerful proprietary LLMs such as GPT-4, significantly underperform when no human-curated reference answer is available (Ye et al., ; Zheng et al., ).
In contrast, *reference-based* evaluation, where a human-curated reference answer is available, shows significantly higher correlation with human evaluations of outputs.
This poses a chicken-and-egg problem: how can we leverage reference-based LLM judges for test time generation if no human references are available?

Minimum Bayes Risk (MBR) decoding (Bickel & Doksum, ) provides a way of overcoming this problem. In place of the inaccessible human references, MBR decoding leverages other candidate outputs as pseudo-references, and uses the evaluator, also known as the utility metric, to conduct reference-based evaluation of all candidate outputs against all pseudo-references. The final output is then chosen as the candidate output with the highest average score: see Figure 1.

Figure: Figure 1: Illustration of MBR decoding. Multiple candidates are first sampled from an LLM. Then, each candidate is evaluated against all other candidates (pseudo-references) using a reference-based evaluator. The pseudo-references are marginalised to produce final scores, and the candidate with the highest score is selected.
Refer to caption: x1.png

In this work, we explore whether MBR decoding using LLM judges as utility metrics can be used to enhance instruction-following LLMs. We divide our work into two main parts. First, inspired by the effectiveness of scaling inference time compute (Welleck et al., ; Snell et al., ), we investigate whether MBR decoding with LLM judges can improve the performance of instruction-following LLMs during test time (denoted as “MBR inference”) (Section 3). Second, following recent works demonstrating that iterative self-training can improve LLM performance (Xu et al., ; Chen et al., ; Yuan et al., ; Wu et al., ), we examine whether MBR decoding with LLM judges can be used to select high-quality model outputs for use in subsequent iterations of self-training (denoted as “MBR distillation”) (Section 4). This both provides a way of training models without access to external labels and also allows us to mitigate the inference-time costs associated with MBR inference.

From our MBR inference experiments, we find that MBR decoding with LLM judge Prometheus-2-7B (Kim et al., ) improves performance by +3.6% on AlpacaEval and +0.28 on MT-Bench on average across five LLMs relative to greedy decoding. Notably, Llama2-7b with Prometheus MBR decoding outperforms Llama2-13b with greedy decoding on MT-Bench, while Prometheus MBR decoding with Llama2-13b outperforms Llama2-70b with greedy decoding on AlpacaEval 2.0. Gains persist even for large 70B models, demonstrating that small LLM judges can supervise larger LLMs through MBR decoding. We also compare MBR decoding against other methods that use LLM judges for supervision. We show that Prometheus MBR decoding is far more effective than MBR decoding with word match-based metrics (e.g. ROUGE) or semantic similarity-based metrics (e.g. BERTScore). Comparing MBR to BoN decoding, we find that MBR decoding consistently outperforms BoN decoding across multiple LLMs and LLM judges, and that the gains from MBR decoding increase as the supervising LLM judge increases in size and ability.

From our MBR distillation experiments, we find that self-training with Direct Preference Optimisation (DPO) (Rafailov et al., ) on preference pairs selected using MBR decoding (Yang et al., ) with Prometheus-2-7B substantially improves greedy decoding performance. For instance, MBR self-trained Llama2-13b improves by +7.1% on AlpacaEval 2.0 and +0.90 on MT-Bench relative to its baseline SFT counterpart when evaluated using only greedy decoding, far surpassing the corresponding gains from BoN self-training. We also find that MBR self-trained models evaluated with greedy decoding generally match and sometimes exceed the performance of their base models evaluated with MBR decoding, thereby demonstrating that MBR distillation is an effective way of mitigating the inference-time costs of MBR decoding while retaining improved performance.

## 2 Background

Language models are autoregressive probabilistic models; i.e., the probability of a token $y_{i}$ depends on prompt $x$ and all previous tokens in the sequence:

$$ $p(y|x)=\prod_{i=1}^{T}p(y_{i}|y_{i-1},\dots,y_{1},x).$ (1) $$

During inference, outputs are typically obtained either using maximum a-posteriori-based decoding methods that attempt to maximise probability, such as greedy decoding ($y_{i}=\operatorname*{arg\,max}_{y_{i}}p(y_{i}|y_{<i},x)$) and beam search (Graves, ), or by tokenwise sampling from the distribution ($y_{i}\sim p(y_{i}|y_{<i},x)$). Both approaches rely on the model’s distribution as indicative of output quality.

Alternatively, we can first obtain a hypothesis set $\mathcal{H}_{\mathrm{hyp}}$ comprising $N_{\mathrm{cand}}$ candidate outputs from the model (for example, by sampling multiple times), and then select the final output from $\mathcal{H}_{\mathrm{hyp}}$ based on some external criteria. For example, given some reference-free evaluator $u$ (e.g. an LLM judge), best-of-N (BoN) decoding selects the output $\hat{y}\in\mathcal{H}_{\mathrm{hyp}}$ such that

$$ $\hat{y}=\operatorname*{arg\,max}_{y\in\mathcal{H}_{\mathrm{hyp}}}u(y).$ (2) $$

As reference-free estimation of output quality can be a difficult problem, MBR decoding replaces the reference-free evaluator with a reference-based evaluator $u(y,y^{\star})$ (e.g. a reference-based LLM judge) that evaluates candidate $y$ relative to a reference $y^{\star}$.(^1^11Certain evaluators (e.g. LLM judges) are “task-aware”, and take prompt $x$ as an input when performing evaluation. Such utility metrics can then be written as $u(y;x)$ and $u(y,y^{\star};x)$.) In the MBR literature, this evaluator is known as a utility metric (Freitag et al., ; Fernandes et al., ; Finkelstein et al., ). MBR decoding selects the final output $\hat{y}$ that maximises expected utility under the model distribution:

$$ $\hat{y}=\operatorname*{arg\,max}_{y\in\mathcal{H}_{\mathrm{hyp}}}~{} \underbrace{\mathbb{E}_{y^{*}\sim p(y\mid x)}[u(y,y^{*})]}_{\textstyle\approx~ {}\frac{1}{N_{\mathrm{cand}}}\sum_{j=1}^{N_{\mathrm{cand}}}u(y,y^{(j)})},$ (3) $$

where the expectation is approximated as a Monte Carlo sum using model samples $y^{(1)},\ldots,y^{(N_{\mathrm{cand}})}\sim p(y|x)$. In practice, this amounts to computing the utility of each candidate in $\mathcal{H}_{\mathrm{hyp}}$ using all other candidates as (pseudo-)references, and then selecting the candidate with the highest average utility as the final output.(^2^22The expectation can also be computed over a separate set of model outputs known as the evidence set (Eikema & Aziz, ; Bertsch et al., ). We do not explore this setting in our work.) The MBR-decoded output can therefore be interpreted as being the candidate with the highest “consensus” utility as measured by the utility metric, as it achieves the highest average utility when evaluated against all other candidate outputs. It is therefore crucial to choose a reference-based metric that is a good proxy for human preferences as our utility function, as this ensures that a “high-consensus” output corresponds to a “high-quality” output.

## 3 MBR Inference

In this experiment, we investigate using MBR decoding with LLM judge utility metrics to improve instruction-following LLMs at test time.

### 3.1 Experimental Setup

#### 3.1.1 Models and Generation Parameters

We use the chat and instruct variants of the Llama2 (Touvron et al., ) and Llama3 (Dubey et al., ) models in this experiment. All models have undergone prior SFT and demonstrate strong instruction-following and conversation abilities. We generate $N_{\mathrm{cand}}=30$ candidates using temperature sampling with $t=0.3$ for all MBR decoding experiments unless otherwise specified.

#### 3.1.2 MBR Utility Metrics

LLM judge We choose Prometheus-2-7B (Kim et al., ) as our representative reference-based LLM judge. Prometheus is a specialist judge model finetuned from Mistral-7b (Jiang et al., ) that correlates strongly with human judges and GPT-4. It takes as inputs a task prompt, a scoring rubric (see Appendix C), a candidate and a reference, and outputs an explanation of its judgement followed by a score from 1 to 5, which we interpret as a utility score. Crucially, Prometheus can also act as a reference-free judge by simply omitting the reference from its input. This allows us to directly compare MBR with BoN decoding using the same LLM judge utility metric.

We compare using LLM judges for MBR decoding with three other classes of utility metrics:

ROUGE ROUGE (Lin, ) is a word-level F-measure designed for measuring summarisation and machine translation performance (Lin, ). We use ROUGE-1 in our main experiments but include results for other ROUGE variants in Appendix A.3.

BERTScore BERTScore is a neural evaluation metric that computes the token-level contextual similarity between a candidate and a reference. Like ROUGE, BERTScore is not task-aware. As our model outputs may be longer than 512 tokens, we use Longformer-large (Beltagy et al., ) as our BERTScore model, which supports inputs up to 4094 tokens long.

Dense embedders Dense embedders generate contextual embeddings of text passages for use in downstream tasks. One such task is measuring the level of semantic similarity between two text passages (Agirre et al., ). This task is directly relevant to MBR decoding, as we can treat pairs of candidates as text passages and their similarity score as the utility. To the best of our knowledge, using dense embedders as a utility metric for MBR decoding has never been explored before. In our work, we use the instruction-following embedder SFR-Embedder-2_R (Meng et al., ) as our representative dense embedder. We include results for two other dense embedders in Appendix A.3.

#### 3.1.3 Baselines

In addition to greedy decoding and beam search (BS) with $k=10$ beams, we also experiment with longest decoding, where we select the longest candidate from the hypothesis set (as measured in characters) as the final output, and best-of-N (BoN) decoding. We generate $N_{\mathrm{cand}}=30$ candidates using temperature sampling with $t=0.3$ for both longest and BoN decoding. See Appendices A.2 and A.3 for comparison to additional baselines.

#### 3.1.4 Evaluation

AlpacaEval 2.0 AlpacaEval (Li et al., ) is an LLM-based evaluation metric. It consists of an 805-sample, highly diverse single-turn instruction-following conversational dataset and an associated evaluation framework. In AlpacaEval 2.0 (Dubois et al., ), evaluation is conducted by performing head-to-head comparison of candidate answers against GPT-4-generated answers facilitated by a judge LLM. The judge model is prompted to output a single token representing its choice of winner, with the log-probabilities of the token used to compute a weighted win rate. In addition to standard win rates, AlpacaEval 2.0 also provides length-controlled (LC) win rates, which are debiased versions of the standard win rates that control for the length of the outputs. Both the AlpacaEval standard and LC evaluation demonstrate strong correlation with human judgements.

MT-Bench MT-Bench (Zheng et al., ) is an 80-sample, two-turn instruction-following conversational dataset. It can be evaluated using either head-to-head comparison or direct assessment with an LLM judge. In the direct assessment setting, the judge LLM is prompted to generate an explanation followed by a score between 1 and 10, with no reference answer used. MT-Bench with GPT-4-judge matches crowdsourced human preferences well, achieving over 80% agreement, which is the same level of agreement between human evaluators (Zheng et al., ).

We use GPT-4o (OpenAI et al., ) as the LLM judge for both AlpacaEval 2.0 and MT-Bench. For AlpacaEval, we report LC win rates unless otherwise stated. For MT-Bench, we use direct assessment for all experiments. See Appendix B for further details on our evaluation strategy, and Appendix H for human study findings verifying the alignment of our automatic LLM evaluation results with human judgements.

### 3.2 Experimental Results

**Table 1: AlpacaEval 2.0 win rates (%) for various models and decoding strategies, along with the average win rate differences compared to greedy decoding across all models (denoted as Avg. $\Delta$). MBR decoding with Prometheus consistently outperforms all baseline methods and other MBR decoding methods.**
|  | 2-7B | 2-13B | 2-70B | 3-8B | 3-70B | Avg. $\Delta$ |
| --- | --- | --- | --- | --- | --- | --- |
| Greedy | 14.4 | 19.0 | 22.8 | 34.4 | 42.7 | 0 |
| BS | 14.8 | 18.2 | 21.5 | 33.9 | 42.4 | -0.50 |
| Longest | 10.5 | 15.2 | 19.8 | 29.8 | 40.4 | -3.51 |
| Prometheus BoN | 16.4 | 20.8 | 25.0 | 35.5 | 44.3 | 1.74 |
| ROUGE MBR | 16.2 | 20.0 | 24.7 | 35.4 | 43.7 | 1.33 |
| BERTScore MBR | 16.2 | 20.5 | 24.4 | 35.7 | 44.0 | 1.50 |
| SFR-Embedder MBR | 12.1 | 16.6 | 22.2 | 32.5 | 42.8 | -1.42 |
| Prometheus MBR | 17.7 | 23.4 | 26.2 | 37.9 | 46.0 | 3.62 |

**Table 2: MT-Bench scores for various models and decoding strategies, along with the average score differences compared to greedy decoding across all models (denoted as Avg. $\Delta$). MBR decoding with Prometheus consistently outperforms all baseline methods and other MBR decoding methods.**
|  | 2-7B | 2-13B | 2-70B | 3-8B | 3-70B | Avg. $\Delta$ |
| --- | --- | --- | --- | --- | --- | --- |
| Greedy | 5.72 | 5.90 | 6.50 | 7.54 | 8.29 | 0 |
| BS | 5.58 | 5.95 | 6.49 | 7.30 | 8.20 | -0.09 |
| Longest | 5.67 | 6.03 | 6.59 | 7.22 | 8.22 | -0.04 |
| Prometheus BoN | 5.77 | 6.08 | 6.65 | 7.66 | 8.42 | 0.13 |
| ROUGE MBR | 5.78 | 6.11 | 6.68 | 7.63 | 8.31 | 0.11 |
| BERTScore MBR | 5.68 | 6.02 | 6.72 | 7.52 | 8.42 | 0.08 |
| SFR-Embedder MBR | 5.73 | 6.04 | 6.54 | 7.45 | 8.33 | 0.03 |
| Prometheus MBR | 6.10 | 6.26 | 6.79 | 7.69 | 8.50 | 0.28 |

Our main experimental results are documented in Tables 1 and 2.

Prometheus MBR decoding provides significant and consistent gains The gains associated with Prometheus MBR decoding are significantly larger than those associated with other utility metrics, yielding an average improvement of +3.6% on AlpacaEval 2.0 and +0.28 on MT-Bench. For comparison, the performance gap between Llama2-7b and Llama2-13b with greedy decoding is +4.6% on AlpacaEval 2.0 and +0.18 on MT-Bench, while the corresponding gap between Llama2-13b and Llama2-70b is +3.8% and +0.60. Notably, Llama2-7b with Prometheus MBR decoding outperforms Llama2-13b with greedy decoding on MT-Bench, while Prometheus MBR decoding with Llama2-13b outperforms Llama2-70b - a model over five times bigger - with greedy decoding on AlpacaEval 2.0. We also find that Prometheus MBR decoding yields larger gains than Prometheus BoN decoding; we explore this further in Section 3.3.1.

We also highlight that the performance gains associated with Prometheus MBR decoding are significant across models of all sizes, even for much larger models such as Llama3-70b. This scaling property suggests that small judge models can still be used to supervise much larger models.

ROUGE and BERTScore MBR decoding provide small but consistent gains  ROUGE and BERTScore MBR decoding improve average performance relative to greedy decoding by +1.3% and +1.5% on AlpacaEval 2.0 and by +0.11 and +0.08 on MT-Bench respectively. This benefit is present for all models. This improvement suggests that selecting outputs without awareness of the task and using only word- or token-level measures of consistency can still yield meaningful improvements even in the instruction-following setting.

SFR-Embedder MBR decoding fails to yield consistent gains  SFR-Embedder MBR decoding reduces performance relative to greedy decoding by -1.4% on AlpacaEval 2.0 while improving performance by +0.03 on MT-Bench on average. We hypothesise that embedder models, which are trained to distinguish at a high level between text passages, cannot to detect nuanced differences between semantically-similar outputs. We also note that embedder MBR decoding generally selects for longer outputs, which may explain the discrepancy between its performance on AlpacaEval 2.0 (which is length-controlled) and MT-Bench. See Appendix A.4 for analysis on the generation lengths of various decoding strategies.

Beam search and longest decoding degrade performance  Beam search and longest decoding reduce performance relative to greedy decoding by -0.5% and -3.5% on AlpacaEval 2.0 and -0.09 and -0.04 on MT-Bench respectively. The poor performance of beam search further underscores the idea that optimising for output probability alone is not enough to improve output quality.

### 3.3 Analysis of Prometheus MBR decoding

Given the promise shown by Prometheus MBR decoding, we conduct additional experiments to better understand its properties.

Figure: Figure 2: AlpacaEval 2.0 win rates (%) for Llama2-70b with varying hypothesis set size $N_{\mathrm{cand}}$ (left) and generation temperature $t$ (right) values for Prometheus MBR and BoN decoding. Performance for both methods initially increases with $N_{\mathrm{cand}}$ and plateaus at around $N_{\mathrm{cand}}=20$. Performance also initially increases with $t$, but drops rapidly after $t=1.0$.
Refer to caption: x2.png

Prometheus MBR decoding performance vs. $t$ and $N_{\mathrm{cand}}$  We plot AlpacaEval 2.0 win rates as a function of $N_{\mathrm{cand}}$ and $t$ in Figure 2 for Llama2-70b with Prometheus MBR and BoN decoding. We find that performance
initially increases with $N_{\mathrm{cand}}$ but plateaus at around $N_{\mathrm{cand}}=20$, suggesting that expanding the size of the hypothesis set beyond this yields little benefit. Performance also initially increases with $t$, highlighting the benefits of increased candidate diversity, although it rapidly degrades at high temperatures as the individual candidate outputs decline in quality.

Figure: Figure 3: Difference in AlpacaEval 2.0 win rates (%) between Prometheus MBR decoding and greedy decoding averaged over all five LLMs and broken down by question category. A positive value indicates that MBR decoding outperforms greedy decoding on the given category. Orange bars represent the standard error. We find that Prometheus MBR decoding improves performance across a wide range of question categories.
Refer to caption: x3.png

Prometheus MBR decoding performance by question category  We classified questions from the AlpacaEval dataset into one of ten categories using GPT-4o (see Appendix D for details), and then computed the differences in win rates between Prometheus MBR decoding and greedy decoding by question category, averaged over all five LLMs. We find that MBR decoding improves output quality across most question categories. These include reasoning-based categories such as coding and mathematical reasoning, although the largest improvements are seen across writing-based categories such as technical, recommendations and creative writing. We hypothesise that this discrepancy arises due to (1) the higher bar for correctness associated with reasoning tasks which limits the number of good answers that can be found amongst candidate outputs; and (2) limitations of existing utility functions, which may struggle to handle difficult reasoning tasks.

#### 3.3.1 Further Comparisons with Best-of-N Decoding

**Table 3: MT-Bench scores for BoN and MBR decoding with various judge LLMs as utility metrics, along with the average score differences compared to greedy decoding across all models (denoted Avg. $\Delta$). MBR decoding consistently outperforms BoN decoding across all comparable utility metrics.**
|  | 2-7B | 2-13B | 2-70B | 3-8B | 3-70B | Avg. $\Delta$ |
| --- | --- | --- | --- | --- | --- | --- |
| Greedy | 5.72 | 5.90 | 6.50 | 7.54 | 8.29 | 0 |
| Prometheus-2-7B-BoN | 5.77 | 6.08 | 6.65 | 7.66 | 8.42 | 0.13 |
| Prometheus-2-7B-MBR | 6.10 | 6.26 | 6.79 | 7.69 | 8.50 | 0.28 |
| Prometheus-2-8x7B-BoN | 6.01 | 6.17 | 6.80 | 7.75 | 8.41 | 0.24 |
| Prometheus-2-8x7B-MBR | 6.26 | 6.32 | 6.87 | 7.79 | 8.64 | 0.39 |
| JudgeLM-7b-BoN | 5.63 | 5.95 | 6.69 | 7.37 | 8.26 | -0.01 |
| JudgeLM-7b-MBR | 6.00 | 6.11 | 6.79 | 7.69 | 8.44 | 0.22 |
| JudgeLM-33b-BoN | 5.68 | 6.03 | 6.58 | 7.37 | 8.35 | 0.01 |
| JudgeLM-33b-MBR | 5.94 | 6.27 | 6.88 | 7.92 | 8.50 | 0.31 |
| Llama3-70b-Instruct-BoN | 5.77 | 6.16 | 6.57 | 7.39 | 8.35 | 0.06 |
| Llama3-70b-Instruct-MBR | 6.22 | 6.43 | 6.94 | 7.87 | 8.52 | 0.41 |

As BoN decoding can also leverage LLM judges as a utility metric, we conduct additional experiments to compare its performance against MBR decoding. We compare BoN and MBR decoding for five different LLM judges on MT-Bench and report the results in Table 3. In addition to Prometheus-2-7B, we also evaluate its larger sibling Prometheus-2-8x7B, as well as JudgeLM-7b and JudgeLM-33b (Zhu et al., ), which are two judge models finetuned from LLaMA models (Touvron et al., ). We also assess Llama3-70b-Instruct as a zero-shot judge for MBR decoding (see Appendix E for our prompts). All of our chosen judges can act as both reference-free and reference-based judges, allowing us to compare MBR and BoN decoding on a level playing field.(^3^33Because sequence-classifier reward models (Stiennon et al., ) do not support reference-based evaluation, it is not possible to fairly compare BoN decoding with these methods to MBR. We therefore do not discuss this in the main text and report our findings in Appendix F instead.)

We find that MBR decoding consistently outperforms BoN decoding across all selected judge models. This difference is especially large for the JudgeLM models and for Llama3-70b-Instruct, where BoN fails to significantly improve on greedy decoding. One explanation for this discrepancy is that our LLM judges are insufficiently good at reference-free evaluation for BoN decoding to be effective. This idea is supported by prior studies comparing reference-free and reference-based evaluation, which consistently show that reference-free methods tend to underperform, even when using strong judge models like GPT-4 (Ye et al., ; Kim et al., ; Zheng et al., ). Another explanation is that MBR decoding provides a smoothing effect that arises from our use of expected utility in place of utility point estimates for output selection, tying back to our hypothesis that selecting “high-consensus” outputs yields significant benefit. This averaging process reduces the impact of individual mistakes made by the imperfect LLM judge, thereby providing for a more stable and reliable measure of quality. We leave further exploration of these ideas to future work.

Notably, in Table 3, MBR performance improves by scaling the size of the LLM judge, with Prometheus-2-8x7B outperforming Prometheus-2-7B and JudgeLM-33b outperforming JudgeLM-7b. This suggests that improving the LLM judge utility metric directly improves MBR decoding performance and that MBR decoding will benefit as newer and better LLM judges are developed.

## 4 MBR Distillation

Our results so far demonstrate the potential of MBR decoding to significantly improve the test-time performance of instruction-following models, but this comes at the cost of substantial inference-time compute costs due to the linear cost for generating $N_{\mathrm{cand}}$ candidate outputs, and the quadratic cost for computing utility across these candidates. To mitigate this, we explore distilling MBR-decoded outputs back into the model itself and aim to obtain MBR decoding-level (or better) performance without needing to perform MBR decoding at test time.

### 4.1 Experimental Setup

#### 4.1.1 Training an SFT Model

We start by performing SFT on the base Llama2-7b and Llama2-13b models. This is necessary to instil instruction-following behaviour in the models so that they can be used to generate instruction-following self-training data. We choose not to use the official chat variants of these models as we wish to retain full control over the training procedure and avoid inheriting any biases introduced through prior finetuning and alignment.

We use 3000 randomly-drawn samples from UltraChat-200k (Ding et al., ) for SFT. UltraChat is a highly diverse conversational instruction-following dataset created using GPT-3.5-Turbo. Each sample consists of multi-turn prompts and responses, although we only take the first turn of each sample in order to simplify experimentation. We designate our SFT models as sft.

#### 4.1.2 Iterative DPO on MBR-Decoded Outputs

Having obtained SFT models, we now conduct DPO to improve the models on their own MBR-decoded outputs, an approach first proposed by Yang et al. () for improving machine translation. We start by randomly drawing a further 3000 prompts from UltraChat (excluding the samples that have already been selected for SFT). Next, we generate $N_{\mathrm{cand}}=12$ candidate outputs from our sft models using these prompts. Following Yang et al. (), we then score the candidate outputs using a utility metric and form preference pairs from the highest-scoring and lowest-scoring outputs. This preference pair dataset is then used for DPO on the sft models, yielding dpo-MBR-1. We extend upon Yang et al. () by iteratively repeating this process twice more, each time using the latest dpo models as the base model paired with a fresh set of 3000 prompts, yielding the models dpo-MBR-2 and dpo-MBR-3. See Appendix I for a summary of our SFT and DPO hyperparameters and Appendix G.4 for experimental results from using another preference pair selection strategy.

#### 4.1.3 Utility Metrics and Evaluation

We use Prometheus-2-7B as our utility metric, as this yielded the most promising results in our earlier experiments (Section 3.2), although we also try MBR self-training with ROUGE as the utility metric (Appendix G.3). We compare our dpo models with greedy decoding against the sft models with greedy decoding, beam search and MBR decoding. For MBR decoding, we use $N_{\mathrm{cand}}=30$ and $t=0.3$ with Prometheus-2-7B as the utility metric. We also baseline against models trained with SFT on 12000 UltraChat samples that we call sft-full. Finally, we experiment with BoN self-training, again using Prometheus-2-7B as the utility metric and following the same procedure as for MBR self-training, which yields the models dpo-BoN-1, dpo-BoN-2 and dpo-BoN-3.

We evaluate our trained models using greedy decoding on AlpacaEval 2.0, once again reporting length-controlled win rates vs. GPT-4, and MT-Bench. As we only train our models to engage in single-turn conversations we evaluate only on the first turn of MT-Bench. We report additional evaluation results in the Appendix, including head-to-head results between various self-trained models and sft with greedy decoding (Appendix G.1), evaluation results on a selection of popular NLP benchmarks (Appendix G.2), and human study results (Appendix H).

### 4.2 Results

**Table 4: (Left) AlpacaEval 2.0 win rates (%) and MT-Bench scores for models self-trained using DPO. After three rounds of training, the self-trained models consistently outperform their BoN counterparts and SFT baselines. (Top) AlpacaEval 2.0 win rates (%) and MT-Bench scores for models self-trained using SFT. Self-training with SFT yields substantially worse results than self-training with DPO.**
|  | AlpacaEval 2.0 | MT-Bench |  |  |
| --- | --- | --- | --- | --- |
|  | 7B | 13B | 7B | 13B |
| sft w. Greedy | 5.18 | 8.24 | 5.43 | 5.85 |
| sft w. MBR | 9.99 | 13.6 | 5.78 | 6.31 |
| sft-full | 6.35 | 9.40 | 5.55 | 6.26 |
| dpo-1-BoN | 5.78 | 10.3 | 5.78 | 6.08 |
| dpo-2-BoN | 6.22 | 11.2 | 5.91 | 6.41 |
| dpo-3-BoN | 6.40 | 12.8 | 5.88 | 6.56 |
| dpo-1-MBR | 5.68 | 10.8 | 5.78 | 6.48 |
| dpo-2-MBR | 7.22 | 13.9 | 6.11 | 6.73 |
| dpo-3-MBR | 8.86 | 15.3 | 6.14 | 6.75 |

Figure: Figure 4: Differences in AlpacaEval 2.0 win rates (%) between dpo-3-MBR models and their respective sft with greedy decoding baselines on different question categories. The largest improvements are seen in open-ended writing tasks, with less improvement on reasoning-focussed tasks (e.g. mathematical reasoning and coding).
Refer to caption: x4.png

Figure: Figure 5: (Left) AlpacaEval 2.0 win rate (%) vs. sft with greedy decoding against generation throughput. dpo-3-MBR with greedy decoding matches the performance of sft with MBR decoding, but with significantly higher throughput. (Right) Average generation and decoding times on the AlpacaEval dataset. The decoding step in MBR decoding takes disproportionately long. This problem can mitigated through MBR self-training.
Refer to caption: x5.png

DPO self-training significantly improves model performance We report the results of our self-training experiment in the left subtable of Table 4. We find that three rounds of MBR self-training with DPO significantly improves model performance, with the 7B dpo-3-MBR model outperforming the 13B sft model with greedy decoding on both AlpacaEval 2.0 and MT-Bench. The improvements saturate by the third round of self-training as measured on MT-Bench (6.11 vs. 6.14 (7B) and 6.73 vs. 6.75 (13B) in Table 4), although there appears to be room for further improvement on AlpacaEval 2.0 (7.22 vs. 8.86 (7B) and 13.9 vs. 15.3 (13B) in Table 4). Both dpo-3-MBR models outperform their sft-full counterparts, which suggests that training on MBR-decoded outputs is more beneficial than SFT on a larger split of UltraChat. The dpo-3-MBR models also generally outperform sft with MBR decoding, and this is especially prominent for MT-Bench, which suggests that DPO on MBR-decoded outputs enables models to recover and then exceed their MBR-decoding performances. We find that DPO on BoN-decoded outputs also improves model performance, although less so than DPO with MBR-decoded outputs. We attribute this to the relative strength of MBR decoding.

SFT self-training yields smaller gains than DPO self-training We experiment with iterative SFT self-training, using the 7B sft model. We document our results in the right subtable of Table 4. We use the same sets of prompts as for DPO and select as our SFT labels the highest-scoring sample as determined by MBR, following Finkelstein et al. (). As before, we conduct three rounds of iterative training, yielding sft-1-MBR, sft-2-MBR and sft-3-MBR. We find that SFT training yields significantly less improvement than DPO. This indicates that MBR self-training benefits most from preference learning, where the model learns to contrast its highest- and lowest-quality outputs.

DPO self-trained model performance by question category We repeat the analysis on performance by question category for dpo-3-MBR in Figure 4. Self-training improves performance on almost all question categories, with generally larger improvement on writing-based categories and smaller improvement on reasoning-based categories. We attribute this difference to the writing-skewed distribution of question categories in our UltraChat training data (see Appendix G.5).

Analysis of compute costs We illustrate the savings on compute introduced by self-training in Figure 5. We perform inference with various 7B models and decoding strategies on AlpacaEval 2.0, using 2xA100 GPUs and vLLM (Kwon et al., ) as our inference engine. We use a generation batch size of 1, a LLM judge utility calculation batch size of 32, and $N_{\mathrm{cand}}=12$. We find that MBR decoding imposes significant overhead, largely due to the quadratic $\mathcal{O}({N_{\mathrm{cand}}^{2}})$ cost incurred during the utility calculation step. This overhead is removed through MBR self-training, which nonetheless retains performance gains. Note that dpo-3-MBR generates longer outputs than sft, which explains why its average generation time as seen in the right-hand plot of Figure 5 is higher.

## 5 Related Work

MBR decoding MBR decoding has been explored in the context of machine translation using a variety of translation metrics such as COMET (Rei et al., ) and BLEURT (Sellam et al., ), with promising results (Freitag et al., ; ; Farinhas et al., ; Stanojević & Sima’an, ). Prior works (Bertsch et al., ; Jinnai et al., ) also study MBR decoding for summarisation, using ROUGE and BERTScore as metrics. Suzgun et al. () apply MBR decoding to several tasks, including summarisation, machine translation and three different BIG-Bench tasks (Srivastava et al., ). None of these works explore the use of MBR decoding in the more open-ended instruction-following domain, nor do they consider using LLM judges as utility metrics.

LLM judges Based on the strong instruction-following capabilities of LLMs, recent works explore prompting LLMs to judge responses from other LLMs (Li et al., ; Zheng et al., ). Follow-up works suggest that training on the evaluation traces of strong models may equip smaller models with strong evaluation capabilities (Kim et al., ; ; Zhu et al., ; Vu et al., ; Wang et al., ). These works focus on training LLMs to produce scoring decisions matching those of humans. In our work, instead of viewing evaluation as an end goal, we explore utilising the evaluation capabilities of LLM judges as supervision to improve instruction-following LLMs.

Inference-time algorithms Many inference-time algorithms generate multiple candidate outputs and select a final output based on external criteria. In addition to MBR and BoN decoding, examples of such algorithms include Self-Consistency (Wang et al., ), which selects the most self-consistent answers through marginalisation of chain-of-thought reasoning paths and Universal Self-Consistency (USC) (Chen et al., ), where the LLM is used to self-select the most consistent chain-of-thought reasoning path from amongst many reasoning paths. Kuhn et al. () propose an MBR-esque algorithm that uses dense embedders and clustering to measure semantic uncertainty. Other inference-time algorithms prompt the LLM to perform additional inference steps in a structured manner. Examples include Tree-of-Thoughts (Yao et al., ) and Graph-of-Thoughts (Besta et al., ), as well as recursive improvement strategies such as Self-Refine (Madaan et al., ) and Reflexion (Shinn et al., ).

Self-training
Self-training is a promising avenue for model improvement as it enables training without external labelled data. Gulcehre et al. () introduce an algorithm that iteratively generates samples from a policy and then updates the policy using offline RL. Yuan et al. () train models to score their own outputs, and then use these scores to create preference datasets which they distil back into the model using DPO. Huang et al. () train models on their own highest-confidence outputs as determined by majority voting. Self-training on MBR-decoded outputs has also been explored for machine translation. Finkelstein et al. () train models with SFT on their own MBR and quality estimation outputs for machine translation and demonstrate that this yields improvements over baseline models. Wang et al. () use MBR to generate targets for sequence-level distillation, again for machine translation. Yang et al. () are the first to use DPO to upweight the model’s own MBR generations, allowing them to recover much of their original MBR performances on machine translation using only greedy decoding.

## 6 Conclusion

In this work, we investigate using LLM judges to supervise other LLMs on instruction-following tasks through MBR decoding, and find that this yields significant and consistent improvements to model performance relative to greedy decoding, beam search and BoN decoding. These benefits persist across a wide range of question categories and are also consistent across models of various sizes, demonstrating that small LLM judges can be used to improve much larger LLMs at inference time. To mitigate the significant inference-time costs associated with MBR decoding, we also explore iterative self-training on MBR-decoded outputs. We find that MBR self-training using DPO, but not SFT, enables models to recover and even exceed their base MBR decoding performance using only greedy decoding. We hope our work further highlights the potential of using LLM judges for supervision and inspires future research into MBR decoding beyond its traditional domains and applications, particularly through the development of new utility metrics.

## Reproducibility Statement

In an effort to make our work reproducible, we document all prompts (Appendices E and B), as well as training and inference hyperparameters (Appendix I) used throughout our experiments. We also include version information for all API-based LLMs (Appendix B), and choose to use open-source models (the Llama2, Llama3, Prometheus-2 and JudgeLM families) where possible.

## Appendix A MBR Decoding: Additional Results

This section presents additional results from our experiments exploring the use of MBR decoding to improve test-time performance.

### A.1 Additional MBR Utility Metrics

**Table 5: AlpacaEval 2.0 win rates (%) for additional MBR decoding experiments, along with the average win rate differences compared to greedy decoding across all models (denoted Avg. $\Delta$).**
|  | Llama2-7B | Llama2-70B | Avg. $\Delta$ |
| --- | --- | --- | --- |
| Greedy | 14.4 | 22.8 | 0 |
| ROUGE-1 MBR | 16.2 | 24.7 | 1.85 |
| SFR-Embedder MBR | 12.1 | 22.2 | -1.45 |
| Prometheus MBR | 17.7 | 26.2 | 3.35 |
| ROUGE-2 MBR | 16.6 | 24.6 | 2.00 |
| ROUGE-L MBR | 15.5 | 24.7 | 1.50 |
| NVEmbed-Embedder MBR | 14.1 | 22.1 | -0.50 |
| Nomic-Embedder MBR | 16.3 | 24.1 | 1.60 |

We experiment with two additional ROUGE variants and two additional dense embedders as utility metrics. The two ROUGE variants are ROUGE-2 and ROUGE-L, which detect bigram overlap and longest co-occurring n-gram overlap respectively. The two dense embedders are NVEmbed-v2 (Lee et al., ) and Nomic-Text-v1.5 (Nussbaum et al., ), which, like SFR Embedder, are strong, long-context dense embedders that rank highly on the MTEB leaderboard Muennighoff et al. ().

We find that MBR decoding with ROUGE-2 performs slightly better than MBR decoding with ROUGE-1, while MBR decoding with ROUGE-L performs slightly worse. MBR decoding with NVEmbed and Nomic both perform better than MBR decoding with SFR Embedder, with Nomic showing some improvement relative to greedy decoding. The latter result suggests that dense embedders could potentially be used for MBR decoding, although further work is required to understand what properties make for good MBR embedders. Overall, none of our additional utility metrics provide comparable improvements to MBR with Prometheus.

### A.2 Comparison with Universal Self-Consistency

We compare MBR decoding to Universal Self-Consistency (USC)
(Chen et al., ). In USC, $N_{\mathrm{cand}}$ outputs are sampled from the LLM and passed directly to the LLM for consistency detection. This entails prompting the LLM to choose the most consistent output. In Chen et al. (), the authors demonstrate that USC improves over greedy decoding for mathematical reasoning, code generation, summarisation and question-answering.

The limited context lengths of LLMs poses a significant challenge when using USC, as it requires fitting all $N_{\mathrm{cand}}=30$ samples into a single prompt. In contrast, MBR decoding only requires fitting two outputs into a single prompt as utility is computed pairwise. As our existing choice of models have limited context lengths (4096 tokens for Llama2, 8192 tokens for Llama3) and our outputs can be long (up to 1024 tokens), we are unable to assess USC on equal footing with MBR decoding using these models without significantly reducing $N_{\mathrm{cand}}$. In order to facilitate a fair comparison, we therefore use the Llama-3.1 models (Dubey et al., ) in place of the Llama2 and Llama3 models for this experiment. The Llama-3.1 models possess context lengths of 128k, thereby allowing us to fit all $N_{\mathrm{cand}}$ samples into a single to prompt as required. Our USC prompt is as follows:

You are given a collection of 30 responses to a prompt. Select the most consistent response based on majority consensus. The most concistent response should be the most representative of all the responses provided. You should consider a variety of factors when evaluating consistency, including content, arguments and examples employed, style, structure and final answer, if relevant. Do not pass judgement on the quality or correctness of the response. Consider only consistency.
Provide a short explanation of your choice, followed by your choice. Your choice should follow this format: "Most Consistent Response: [[Response ID]]", for example: "Most Consistent Response: [[15]]" if response 15 is the most consistent amongst all responses.
Responses: {responses}

**Table 6: AlpacaEval 2.0 win rates (%) for Llama3.1 models with greedy decoding, USC and MBR decoding with Prometheus, along with the average win rate differences compared to greedy decoding across all models (denoted Avg. $\Delta$).**
|  | Llama3.1-8B | Llama3.1-70B | Avg. $\Delta$ |
| --- | --- | --- | --- |
| Greedy | 34.2 | 42.1 | 0 |
| USC | 37.3 | 43.7 | 2.35 |
| MBR Prometheus | 40.2 | 45.8 | 4.85 |

We document our findings in Table 6. We find while that USC provides some improvements over greedy decoding, this improvement is smaller than the improvement provided by MBR decoding with Prometheus.

### A.3 Sampling Baselines

We conduct additional baseline experiments with top-$p$ (Holtzman et al., ) and top-$k$ (Fan et al., ) sampling. We use these sampling methods to directly obtain a final output, and do not explore using replacing temperature sampling with these sampling strategies for generating the hypothesis set - we leave this to future work.

**Table 7: AlpacaEval 2.0 win rates for top-$p$ and top-$k$ decoding, along with the average score differences compared to greedy decoding across all models (denoted Avg. $\Delta$). Top-$p$ and top-$k$ sampling improve over greedy decoding, but do not match the performance improvements of Prometheus MBR decoding.**
|  | Llama2-7B | Llama2-70B | Avg. $\Delta$ |
| --- | --- | --- | --- |
| Greedy | 14.4 | 22.8 | 0 |
| ROUGE-1 MBR | 16.2 | 24.7 | 1.85 |
| Prometheus MBR | 17.7 | 26.2 | 3.35 |
| top-$p$ ($p=0.9$, $t=0.3$) | 14.3 | 23.7 | 0.40 |
| top-$p$ ($p=0.9$, $t=0.7$) | 14.7 | 23.9 | 0.70 |
| top-$p$ ($p=0.5$, $t=0.3$) | 15.3 | 24.9 | 1.50 |
| top-$p$ ($p=0.5$, $t=0.7$) | 15.0 | 24.9 | 1.35 |
| top-$k$ ($k=50$, $t=0.3$) | 14.7 | 23.6 | 0.55 |
| top-$k$ ($k=50$, $t=0.7$) | 15.0 | 23.5 | 0.65 |
| top-$k$ ($k=20$, $t=0.3$) | 15.0 | 24.7 | 1.25 |
| top-$k$ ($k=20$, $t=0.7$) | 14.7 | 24.0 | 0.75 |

We find that top-$p$ and top-$k$ sampling improves over greedy decoding, and can achieve performance close to that of MBR decoding with ROUGE. The improvements are nonetheless much smaller than MBR decoding with Prometheus. Nonetheless, these results demonstrate that top-$p$ and top-$k$ sampling could be used to produce hypothesis sets containing higher quality candidates, which could in turn improve downstream MBR decoding performance. We believe this is an exciting avenue for future work.

### A.4 Generation Lengths

Figure: Figure 6: Average generation lengths (in words) for various decoding strategies, averaged over all five generator LLMs. MBR with Prometheus produces slightly longer outputs than most baseline methods, although these outputs are still far shorter than those produced by MBR with SFR-embedder and by the longest decoding baseline.
Refer to caption: x6.png

Figure: Figure 7: Average generation lengths (in words) for various models and decoding strategies on AlpacaEval. MBR with Prometheus produces slightly longer outputs than most baseline methods, although these outputs are still far shorter than those produced by MBR with SFR-embedder and by the longest decoding baseline.
Refer to caption: x7.png

We compute the average generation lengths (in words) of our five generator LLMs on AlpacaEval 2.0 with different decoding strategies and plot the results in Figures 6 and 7. We find that MBR decoding with Prometheus yields outputs that are on average longer than those yielded by greedy decoding, beam search or Prometheus BoN decoding. They are nonetheless much shorter than the outputs yielded by MBR decoding with SFR-Embedder and decoding by selecting the longest output. We hypothesise that MBR decoding with Prometheus encourages selection of more detailed responses which improves model performance, although we note that verbosity alone is not enough to improve performance on our benchmarks as the longest baseline fails to yield any gains, and as we use length-controlled metrics for evaluation.

## Appendix B GPT-4o-Judge Details

We use GPT-4o as a judge for both AlpacaEval 2.0 and MT-Bench. More specifically, we use gpt-4o-2024-05-13, accessed through an Azure endpoint.

For AlpacaEval 2.0, we use the official AlpacaEval implementation(^4^44github.com/tatsu-lab/alpaca_eval) to conduct evaluation. We use the weighted_alpaca_eval_gpt4_turbo evaluator and baseline results against the default gpt-4-1106-preview generations unless other specified.

For MT-Bench, we use the single- and multi-turn judge prompts provided by LLMSYS FastChat(^5^55github.com/lm-sys/FastChat) as our judge prompts. Due to stochasticity in the outputs of the judge models, even with temperature set to zero, we generate three judgements per sample and take as the final score the median of the three judgement scores.

## Appendix C Prometheus Scoring Rubrics

Prometheus takes as input a scoring rubric that defines scoring criteria to be used during evaluation. We use a single, generic scoring rubric for all our experiments:

[Consider a wide range of factors such as the helpfulness, relevance, accuracy, depth, creativity, and level of detail of the response.]
Score 1: The answer is completely unhelpful and incorrect. Nothing useful can be learned from it.
Score 2: The answer contains some helpful and useful information, but major flaws, in terms of facuality, accuracy and relevance, are also present.
Score 3: The answer is mostly helpful and relevant, although minor flaws exist.
Score 4: The answer is accurate, relevant and helpful, although there are some clear improvements that can be made with respect to depth, creativity and detail.
Score 5: The answer is excellent. It is completely accurate and relevant, and demonstrates a high degree of depth and creativity.

We hypothesise that the performance of MBR and BoN decoding with Prometheus could be improved through further optimisation of the scoring rubric, particularly with question-specific adjustments, where unique rubrics are tailored to each question. We leave this to future work.

## Appendix D AlpacaEval Categories

We classify questions from AlpacaEval and MT-Bench and then evaluate performance by category.

For AlpacaEval, we perform manual inspection on the dataset and identify ten common question categories. We then use GPT-4o to classify questions based on these categories, using the following prompt:

Categorise an instruction based on the following list of categories. Only choose one category, and only return the category, nothing else.
- Creative writing
- Business, technical and scientific writing
- Argumentation, debate and persuasion
- Mathematical reasoning
- Puzzles and logical reasoning
- Coding
- How-to and other guides
- Recommendations and advice
- Factual question-answering
- Other
Example Instruction: Bob has 5 sisters and 1 brother. How many siblings does one of Bob’s sisters have?
Category: Puzzles and logical reasoning
Example Instruction: Write me a resignation email for my job as an accountant, explaining that I am leaving to pursue my dream of becoming a lion tamer.
Category: Business, technical and scientific writing
Example Instruction: What factors gave rise to the English Civil War.
Category: Factual question-answering
Example Instruction: I am visiting Kyoto next April. Recommend me 10 things to do!
Category: Recommendations and advice
Example Instruction: Pretend to be Donald Trump - write a speech announcing that you are becoming a Democrat.
Category: Creative Writing
Instruction: {instruction}
Category:

The percentage of questions assigned to them are listed in Table 8.

**Table 8: AlpacaEval question categories identified by GPT-4o.**
| Category | Percentage of Questions |
| --- | --- |
| Factual question-answering | 24.3 |
| How-to and other guides | 20.6 |
| Recommendations and advice | 12.1 |
| Mathematical reasoning | 3.2 |
| Other | 2.2 |
| Creative writing | 11.8 |
| Business, technical and scientific writing | 12.7 |
| Puzzles and logical reasoning | 3.5 |
| Coding | 6.7 |
| Argumentation, debate and persuasion | 2.7 |

The results of our performance by category analysis for MBR decoding with Prometheus on AlpacaEval are illustrated in the main text, in Figure 3.

## Appendix E Llama3 as an MBR and BoN Utility Metric

We experiment with using Llama3-70b-Instruct as an MBR and BoN utility metric in Section 3.3.1. This entails prompting the model to act as either a reference-based or reference-free evaluator.

Our prompt for single-turn reference-based evaluation is as follows:

[Instruction]
Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. In addition to the user question, you are also given a reference answer. This is the best possible answer provided by a human expert. You should evaluate the assistant’s response based on this. A good assistant’s answer should share the content and style of the reference answer. Begin your evaluation by providing a short explanation. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 1 to 10 by strictly following this format: "[[rating]]", for example: "Rating: [[5]]".
[Question]
{question}
[Reference Answer]
{reference}
[The Start of Assistant’s Answer]
{answer}
[The End of Assistant’s Answer]

Our prompt for single-turn reference-free evaluation is as follows:

[Instruction]
Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Begin your evaluation by providing a short explanation. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 1 to 10 by strictly following this format: "[[rating]]", for example: "Rating: [[5]]".
[Question]
{question}
[The Start of Assistant’s Answer]
{answer}
[The End of Assistant’s Answer]

For multi-turn evaluation, we use a system prompt to specify the rules. For reference-based evaluation:

Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should focus on the assistant’s answer to the second user question. In addition to the user question and conversation history, you are also given a reference answer. This is the best possible answer to the second user question provided by a human expert. You should evaluate the assistant’s response based on this. A good assistant’s answer should share the content and style of the reference answer. Begin your evaluation by providing a short explanation. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 1 to 10 by strictly following this format: "[[rating]]", for example: "Rating: [[5]]".

For multi-turn, reference-free evaluation:

Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should focus on the assistant’s answer to the second user question. Begin your evaluation by providing a short explanation. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 1 to 10 by strictly following this format: "[[rating]]", for example: "Rating: [[5]]".

The prompt template for both reference-based and reference-free multi-turn evaluation is:

<|The Start of Assistant A’s Conversation with User|>
### User:
{question_1}
### Assistant A:
{answer_1}
### User:
{question_2}
### Assistant A:
{answer_2}
<|The End of Assistant A’s Conversation with User|>

## Appendix F Reward Model as a BoN Utility Metric

**Table 9: MT-Bench scores for various models and decoding strategies, along with the average score differences compared to greedy decoding across all models (denoted Avg. $\Delta$). BoN decoding with reward model StarlingRM-7b marginally outperforms MBR decoding with Prometheus.**
|  | 2-7B | 2-13B | 2-70B | 3-8B | 3-70B | Avg. $\Delta$ |
| --- | --- | --- | --- | --- | --- | --- |
| Greedy | 5.72 | 5.90 | 6.50 | 7.54 | 8.29 | 0 |
| BS | 5.58 | 5.95 | 6.49 | 7.30 | 8.20 | -0.09 |
| Prometheus BoN | 5.77 | 6.08 | 6.65 | 7.66 | 8.42 | 0.13 |
| Starling-RM-7b BoN | 5.99 | 6.49 | 6.85 | 7.88 | 8.46 | 0.34 |
| Prometheus MBR | 6.10 | 6.26 | 6.79 | 7.69 | 8.50 | 0.28 |

We evaluate BoN decoding using Starling-RM-7B-alpha (Zhu et al., ) as the utility metric. Starling-RM is a strong 7B sequence classifier reward model trained to facilitate RLHF (Stiennon et al., ) that achieves a similar overall score to Prometheus-2-7B on RewardBench (Lambert et al., ). It takes as inputs a prompt and a single candidate and outputs a scalar reward. As with reward models in general, Starling-RM does not support reference-based evaluation.

We find that BoN decoding with Starling-RM as a utility metric outperforms MBR decoding with Prometheus by a small margin. We have two possible explanations for this discrepancy. Firstly, Starling-RM achieves a much higher score than Prometheus-2-7B on RewardBench’s Chat task (likely due to the distribution of its training data), suggesting that it may simply be more suited to our particular benchmarks. Secondly, by providing continuous scalar rewards instead of discrete integer scores, Starling-RM enables more fine-grained evaluation of candidate outputs, allowing it to distinguish between outputs that Prometheus might have rated equally. We believe that using a reference-based reward model as the metric for MBR decoding could combine the advantages of fine-grained scoring with the increased reliability of consensus-based output selection. We leave the development of such models to future work.

## Appendix G Self-Training: Additional Results

### G.1 Head-to-Head Results

Figure: Figure 8: AlpacaEval 2.0 win rates (%) for self-trained models and various SFT baselines against sft with greedy decoding. Generation for all $dpo$ models is done with greedy decoding. We find that MBR self-training with DPO allows models to match their MBR-decoding performance.
Refer to caption: x8.png

We conduct head-to-head evaluation of our DPO self-trained models and various SFT baselines against sft with greedy decoding using the AlpacaEval 2.0 and illustrate our findings in Figure 8. Our head-to-head results show that our MBR self-trained models outperform our BoN self-trained models, the sft with beam search baseline, and the full sft with greedy decoding baseline. Our MBR self-trained models match the performance of the sft with MBR decoding baseline.

### G.2 Results on NLP Benchmarks

**Table 10: Evaluation results of Prometheus self-trained models on four different NLP benchmarks. We find that MBR and BoN self-training maintains performance on across all four datasets compared with the sft models.**
|  | Model | MMLU $(\uparrow)$ | ARC challenge $(\uparrow)$ | HellaSwag $(\uparrow)$ | TruthfulQA $(\uparrow)$ |
| --- | --- | --- | --- | --- | --- |
| 7B | sft | 47.2 | 57.3 | 80.6 | 51.6 |
| dpo-3-BoN | 47.2 | 57.5 | 80.6 | 53.5 |  |
| dpo-3-MBR | 47.3 | 57.1 | 80.7 | 52.6 |  |
| 13B | sft | 56.1 | 62.3 | 83.5 | 48.4 |
| dpo-3-BoN | 56.3 | 62.5 | 83.5 | 48.2 |  |
| dpo-3-MBR | 56.1 | 62.6 | 83.5 | 47.4 |  |

We assess our self-trained models on four different NLP benchmarks: MMLU (Hendrycks et al., ), ARC challenge (Clark et al., ), HellaSwag (Zellers et al., ) and TruthfulQA (Lin et al., ), and report our results in Table 10. We find that self-training maintains performance across all four benchmarks despite us using a training dataset that is irrelevant for these tasks. This shows that MBR self-training can be used to improve the instruction-following abilities of models without jeopardising other skills.

### G.3 MBR Self-Training with ROUGE

**Table 11: AlpacaEval 2.0 win rates (%) and MT-Bench scores for models self-trained using DPO with Prometheus and with ROUGE-1 as utility metrics. MBR self-training with ROUGE fails to yield substantial gains.**
|  | AlpacaEval 2.0 | MT-Bench |  |  |
| --- | --- | --- | --- | --- |
|  | 7B | 13B | 7B | 13B |
| sft | 5.18 | 8.24 | 5.43 | 5.85 |
| dpo-1-MBR-Prometheus | 5.68 | 10.8 | 5.78 | 6.48 |
| dpo-2-MBR-Prometheus | 7.22 | 13.9 | 6.11 | 6.73 |
| dpo-3-MBR-Prometheus | 8.86 | 15.3 | 6.14 | 6.75 |
| dpo-1-MBR-ROUGE | 4.66 | 5.61 | 7.65 | 5.98 |
| dpo-2-MBR-ROUGE | 5.83 | 5.78 | 9.01 | 6.06 |
| dpo-3-MBR-ROUGE | 5.42 | 5.67 | 8.31 | 5.91 |

We explore using ROUGE-1 as the utility metric for MBR self-training. We find that MBR self-training with ROUGE fails to yield substantial gains. Improvements also saturate quickly, with model performance decreasing after the third training iteration. These results highlight the importance of choosing the correct MBR utility metric for self-training.

### G.4 Alternative Pair Selection Strategies

**Table 12: AlpacaEval 2.0 win rates (%) and MT-Bench scores for models self-trained using DPO with BW and BMW preference pair selection strategies with sft-7b as the base model. Generation is done using greedy decoding for all models. We find that our BMW models perform similarly to the original BW models on AlpacaEval 2.0 and slightly worse on MT-Bench.**
|  | AlpacaEval 2.0 | MT-Bench |
| --- | --- | --- |
| sft | 5.18 | 5.43 |
| dpo-1-MBRBW | 5.68 | 5.78 |
| dpo-2-MBRBW | 7.22 | 6.11 |
| dpo-3-MBRBW | 8.86 | 6.14 |
| dpo-1-MBRBMW | 4.95 | 5.78 |
| dpo-2-MBRBMW | 8.06 | 5.96 |
| dpo-3-MBRBMW | 8.88 | 5.97 |

We investigate using an alternative MBR preference pair selection strategy. Following Yang et al. (), we create two preference pairs from each sample, one formed from the highest-scoring (best) and median-scoring (mid) outputs, and another formed from the median-scoring and lowest-scoring (worst) outputs. We follow the exact same DPO training procedure as before, but replace our original BW training set with this new BMW training set.

We document our results in Table 12. We find that our BMW models perform similarly to the original BW models on AlpacaEval 2.0 and slightly worse on MT-Bench. We do not pursue this line of work further and leave additional investigations to future work.

### G.5 Performance by Category

**Table 13: UltraChat-200k question categories identified by GPT-4o. We perform this analysis on a subsample of 1000 prompts sampled randomly from our 12000 training prompts.**
| Category | Percentage of Questions |
| --- | --- |
| Factual question-answering | 26.4 |
| How-to and other guides | 21.1 |
| Recommendations and advice | 4.4 |
| Mathematical reasoning | 0.1 |
| Other | 1.3 |
| Creative writing | 18.6 |
| Business, technical and scientific writing | 19.0 |
| Puzzles and logical reasoning | 0.1 |
| Coding | 6.3 |
| Argumentation, debate and persuasion | 2.7 |

We replicate the question category analysis described in Section 3.3 and Appendix D for our Prometheus MBR self-trained models and report results in Figure 4. We find that performance relative to the sft models improves across almost all question categories, with performance on writing based categories improving more than on reasoning based categories. Performance on mathematical reasoning remains unchanged for the 7B model and decreases for the 13B model.

To better understand this discrepancy, we sample 1000 prompts from our 12000 UltraChat training prompts and categorise them using GPT-4o, following the same procedure described in Section 3.3 and Appendix D. We document our results in Table 13. We find that reasoning-based questions (coding, puzzles and logical reasoning, mathematical reasoning) are underrepresented in this dataset, with mathematical reasoning and puzzles and logical reasoning especially underrepresented. We attribute our models’ inconsistent improvements in these areas to this lack of data.

### G.6 Generation Lengths

Figure: Figure 9: Average generation lengths (in words) after iterative Prometheus MBR and BoN self-training on AlpacaEval. MBR self-training with DPO teaches the model to generate more detailed responses.
Refer to caption: x9.png

We measure the generation lengths of our Prometheus MBR and BoN self-trained models on AlpacaEval. We find that MBR self-training with DPO teaches the model to generate longer and more detailed responses at every iteration. In contrast, BoN self-training and MBR self-training with SFT only results in small increases in generation lengths.

## Appendix H Human Study

**Table 14: Head-to-head evaluation of Prometheus MBR and Prometheus BoN vs. greedy decoding for Llama2-70b conducted on the AlpacaEval dataset by human evaluators.**
|  | Win | Draw | Loss |
| --- | --- | --- | --- |
| Prometheus MBR vs. Greedy | 30.0 | 53.3 | 16.7 |
| Prometheus BoN vs. Greedy | 21.7 | 60.0 | 18.3 |

**Table 15: Head-to-head evaluation of 13B dpo-3-MBR and dpo-3-BoN vs. sft conducted on the AlpacaEval dataset by human evaluators. Greedy decoding used for all models.**
|  | Win | Draw | Loss |
| --- | --- | --- | --- |
| dpo-3-MBR vs. sft | 46.7 | 43.3 | 10.0 |
| dpo-3-BoN vs. sft | 33.3 | 55.0 | 11.7 |

We conduct a human study for key MBR inference (Section 3) and MBR distillation (Section 4) experiments. The objective of this study is to verify that our LLM evaluation results (AlpacaEval 2.0 and MT-Bench) align with real human judgements.

We recruited 4 volunteers, each of whom were given 60 samples in total to evaluate. Each sample consisted of a randomly-sampled AlpacaEval prompt and two corresponding generations displayed in a random order. Volunteers were asked to select their preferred generation and, if neither generation was preferred, to then rate the generations as equal.

We conducted four head-to-head experiments. The first two experiments, corresponding to experiments in Section 3, were between Prometheus MBR vs. greedy decoding and Prometheus BoN vs. greedy decoding with Llama2-70b. The next two experiments, corresponding to experiments in Section 4, were between 13B dpo-3-MBR vs. sft and dpo-3-BoN vs. sft. We used 60 samples for each experiment. Volunteers were given an even distribution of samples from each experiment.

Our results show good alignment with our LLM evaluation results. We find that Prometheus MBR decoding performs well against greedy decoding, with its win rate higher than the corresponding win rate for Prometheus BoN decoding vs. greedy decoding. We also find that dpo-3-MBR significantly outperforms sft, and its margin of victory is greater than the margin of victory of dpo-3-BoN vs. sft. Furthermore, the margin of improvement associated with MBR distillation is larger than the corresponding margin for MBR inference. These findings align with our findings from our automatic LLM evaluation experiments.

## Appendix I Training and Inference Hyperparameters

**Table 16: Hyperparameters for SFT and MBR self-training with SFT.**
| Hyperparameter | Value |
| --- | --- |
| Learning Rate | 5$e$-6 |
| Num Epochs | 3 |
| Batch Size | 32 |
| Optimiser | AdamW |
| $\beta_{1}$ | 0.9 |
| $\beta_{2}$ | 0.95 |
| $\epsilon$ | 1$e$-8 |
| Weight Decay | 0.1 |
| Scheduler | Cosine |

**Table 17: Hyperparameters for MBR self-training with DPO.**
| Hyperparameter | Value |
| --- | --- |
| Learning Rate | 5$e$-7 |
| Num Epochs | 5 |
| Batch Size | 8 |
| Optimiser | RMSProp |
| $\alpha$ | 0.99 |
| $\beta_{\mathrm{DPO}}$ | 0.1 |
| Scheduler | Constant with warmup |
| Warmup Steps | 150 |

Our SFT and DPO hyperparameters for our self-training experiments in Section 4.2 are provided in Tables 16 and 17. We use bf16 mixed precision training with 8xA100 GPUs for all experiments.

For inference, we use 4xA100 GPUs with bf16 quantisation for all LLMs and judge LLMs, other than for the Analysis of compute costs experiments in Section 4.2, where we use 2xA100 GPUs. We use vLLM (Kwon et al., ) as the inference engine for all experiments.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 8
presentation: 4
questions: Are there any distinctive linguistic features in MBR-decoded outputs? How does it affect diversity, style, or tone?
soundness: 3
strengths: * The paper explores the use of previously developed approaches—specifically, Minimum Bayes Risk (MBR)—for selecting a generation hypothesis at the decoding stage in LLMs. The MBR-selected hypothesis is treated as the one with the highest average utility according to a specified utility metric. The choice of this approach is well-reasoned, with a clear motivation behind it.

* The experimental setup is solid. The paper first demonstrates improvements using MBR decoding. Given its high computational cost, the paper then explores self-training with MBR-decoded outputs, which also leads to improvements. The evaluation is conducted on two standard benchmarks (Alpaca-Eval 2.0 and MT Bench), with comparisons across different decoding approaches and a variety of utility metrics used in MBR. The discussion of results is well-organized, providing clear and comprehensive takeaways.
summary: This paper proposes an approach for selecting one of N generation hypotheses using a Minimum Bayes Risk (MBR) method. MBR decoding alone results in improved performance. However, as MBR decoding is resource-intensive and may not be practical for real-life applications, an alternative use case—self-training with DPO on preference pairs selected via MBR—also demonstrates performance gains.
weaknesses: The paper is well-written and easy to follow. The reviewer does not identify any major weaknesses.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 1
questions: - **Question 1:** How does the performance of MBR decoding with LLM judges compare to other state-of-the-art decoding methods beyond those presented in the paper?
- **Question 2:** Can the authors elaborate on any potential negative impacts of using LLM judges, such as the risk of overfitting to the judge's biases?
- **Question 3:** The hyperparameter N~cond~ is set to 12 for generating candidates for DPO but increased to 30 during decoding. How did the authors determine these values, and how do they align with the experiment illustrated in Figure 2?
soundness: 3
strengths: 1. The application of MBR decoding with LLM judges is a creative approach that combines recent advances in LLM evaluation with decoding techniques.
2. The experiments are thorough, and the benchmarks used are relevant and well-established in the field.
3.  This paper also explores the guiding role of MBR decoding in LLM’s DPO training, which is inspiring in subsequent model training.
summary: The paper presents a novel approach to improving the test-time performance of instruction-following LLMs through the application of Minimum Bayes Risk (MBR) decoding. The authors leverage LLM judges as reference-based evaluators to select high-quality outputs from a set of candidate outputs. They demonstrate that MBR decoding with LLM judges significantly outperforms greedy decoding and other decoding methods without references on benchmarks like AlpacaEval and MT-Bench. Furthermore, the paper explores iterative self-training on MBR-decoded outputs to retain performance improvements while mitigating additional test-time costs. The authors find that self-training using Direct Preference Optimisation leads to significant performance gains, matching or exceeding the performance of base models with MBR decoding.
weaknesses: Main weakness:
- The presentation lacks clarity and reads more like an experimental report than an academic paper. The methods section is merged with the experiments and results, lacking any formal formulations. For instance, in Section 4.1.2, Iterative DPO on MBR-Decoded Outputs, adding mathematical formulations would improve both understanding and reproducibility of the approach.

Others:
- This paper only compares some relatively simple decoding methods. If some better decoding methods such as speculative decoding and medusa can be added, the method will be more credible.
- The paper could also benefit from a discussion on the computational costs associated with MBR decoding and self-training, especially when scaling to larger models or datasets.

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 4
questions: 1. Could the LLM model itself be used as a judge? In the spirit of self-improvement.
Jinnai et al. evaluated their utility metrics on benchmarks without LLM judge. How would LLM judges perform there? (e.g. machine translation, summarization)
2. Could there be some kind of overfitting/bias towards the GPT-4o judge that is dominating the win-rates in the comparison (the “closer” the judge to GPT-4o, the better the MBR)? In the extreme case, what if GPT-4o was used as a judge - I’m sure that would beat even Prometheus. Perhaps one could compare the outputs selected by the evaluated judges to GPT-4o decisions to find out if the ranking of win-rates corresponds to agreeing with GPT-4o.
3. I would love to see some qualitative analysis on how BoN and MBR generation selection differ with the same judge. The paper explains that the smoothing effect of MBR might be helpful to find the best generation, but I would like this to be made a little more built out and supported by examples.
soundness: 3
strengths: 1. The experiments are thorough (and well documented), including multiple sizes of learner and judge models, and multiple utility functions for comparison.
2. The analyses are interesting and well presented, explained and visualized. Important ablations, such as hypotheses size and temperature, are included.
3. The distillation solution is very attractive for boosting performance in practice without sacrificing inference time, which is contributing to a timely trend. There's a good chance this approach will be added to everyone's box of inference tricks.
4. Compute costs are well discussed and addressed with the distillation solution.
Solid and interesting review of past works, especially about Machine Translation where MBR decoding has already become popular.
summary: This paper explores MBR decoding with reference-based LLM judges for selecting one of n outputs for instruction finetuned LLMs at inference time. 
The paper uses Prometheus2, LLama3, and JudgeLM models as a judge for Llama 2 & 3 models and evaluates on AlpacaEval and MT-Bench, comparing MBR decoding with best-of-n inference, and other one-best decoding strategies, and explore non-LLM utility functions for MBR as well.
They find gains across the bench, with smaller judges also being successful as utility function in MBR decoding for guiding larger LLMs. MBR decoding is furthermore combined with self-training (DPO) to yield further gains and overcome the added decoding costs.
weaknesses: 1. The method is not particularly novel, as MBR decoding with LLMs has been studied in the past (as discussed in Related Work), but not with an LLM as judge.
2. Given the novelty being the use of a judge to find the consensus output, I would love to see more analysis on the dependence of the LLM judge’s quality. There is a notable gap with other utility functions, so it would be helpful to understand where they diverge. See questions below.

Meta-review: This paper introduces a novel application of Minimum Bayes Risk (MBR) decoding to enhance the test-time performance of instruction-following LLMs. LLM judges (including Prometheus2, Llama3, and JudgeLM) are used as reference-based evaluators and select high-quality outputs from a set of candidates generated by Llama 2 & 3 models.  Evaluations on AlpacaEval and MT-Bench demonstrate that MBR decoding with LLM judges significantly outperforms greedy decoding and other reference-free decoding strategies, even with smaller LLMs acting as judges. The paper explores iterative self-training on MBR-decoded outputs. MBR decoding is also combined with self-training (DPO) to yield further gains and overcome the added decoding costs. 

There is consensus among the reviewers that the experimental setup and experiments are thorough. The majority of the reviewers agree that the paper is well written, clear to follow, and motivation and results are presented well. One of the concerns raised was the need for comparisons with other decoding methods which is addressed by the authors with speculative decoding results in the rebuttal. Another suggestion was to include a discussion on the computational cost which the authors have included in section 4.2 of the paper and few more details in the rebuttal. Reviewer Z8nY points out that the paper lacks analysis of the dependence of the LLM judge’s quality. The authors rebut with a detailed analysis of this by answering the questions asked by the reviewer. With its solid experimental setup, clear writing, and a rebuttal addressing all key concerns, I am recommending this paper for acceptance.

Decision: Accept (Spotlight)