Title: Discovering Preference Optimization Algorithms with and for Large Language Models
Venue: NeurIPS 2024
Accepted: yes
Keywords: Preference optimization

RLHF

Large Language Models
Abstract: Offline preference optimization is a key method for enhancing and controlling the quality of Large Language Model (LLM) outputs.
Typically, preference optimization is approached as an offline supervised learning task using manually crafted convex loss functions. While these methods are based on theoretical insights, they are inherently constrained by human creativity, so the large search space of possible loss functions remains under-explored. We address this by performing LLM-driven *objective discovery* to automatically discover new state-of-the-art preference optimization algorithms without (expert) human intervention.  Specifically, we iteratively prompt an LLM to propose and implement new preference optimization loss functions based on previously evaluated performance metrics. This process leads to the discovery of previously unknown and performant preference optimization algorithms. The best performing of these we call *Discovered Preference Optimization* (DiscoPOP), a novel algorithm that adaptively blends logistic and exponential losses. Experiments demonstrate the state-of-the-art performance of DiscoPOP and its successful transfer to held-out tasks.

Discovering Preference Optimization Algorithms with and for Large Language Models

Abstract

Offline preference optimization is a key method for enhancing and controlling the quality of Large Language Model (LLM) outputs. Typically, preference optimization is approached as an offline supervised learning task using manually crafted convex loss functions. While these methods are based on theoretical insights, they are inherently constrained by human creativity, so the large search space of possible loss functions remains under-explored. We address this by performing LLM-driven objective discovery to automatically discover new state-of-the-art preference optimization algorithms without (expert) human intervention. Specifically, we iteratively prompt an LLM to propose and implement new preference optimization loss functions based on previously evaluated performance metrics. This process leads to the discovery of previously unknown and performant preference optimization algorithms. The best performing of these we call Discovered Preference Optimization (DiscoPOP) 1 , a novel algorithm that adaptively blends logistic and exponential losses. Experiments demonstrate the state-of-the-art performance of DiscoPOP and its successful transfer to held-out tasks.

1 Introduction

Training Large Language Models (LLMs) usually involves starting with a model pre-trained on large text corpora and then fine-tuning it to match human preferences. Pre-trained, and even instruction fine-tuned LLMs, can generate harmful, dangerous, and unethical completions [Carlini et al., 2021, Gehman et al., 2020]. To mitigate this and align an LLM with human values, we use human preference alignment through preference-ranked completion data. This approach has become an industry standard, popularized by reinforcement learning with human feedback (RLHF) [Christiano et al., 2017, RLHF], and more recently, by offline preference optimization algorithms like direct preference optimization [Rafailov et al., 2023, DPO] and sequence likelihood calibration [Zhao

Claudio Fanconi ∗

‡

Proposal

Extend/Update

Context & Fitness

Optimization Run

CODE-LEVEL JSON FOUNDATION MODEL PROPOSAL:

{"thought": "Based on the previous outputs,...",

"name": "cross_entropy_loss",

"code": "def loss_fn(

logits: torch.FloatTensor,

targets: torch.FloatTensor

) -> torch.FloatTensor:

loss = F.cross_entropy(logits, targets)

return loss"}

SYSTEM PROMPT:

You are a machine learning researcher who is

testing out different loss functions.

.

When you respond, output a JSON where the first key

(

"thought"

) corresponds to your thought process when designing

the next function. The second key (

"name"

) corresponds to the

name of your next function.The last key (

"code"

) corresponds

to the exact python code that you would like to try. Here is

an example: {

<EXAMPLE JSON FORMAT>

}

<QUERY>

: Propose the next one to evaluate.

Add evals & perf.

INNER LOOP EVALUATION OF PROPOSED OBJECTIVE:

LLM-Driven Discovery

Discovered Policy

Optimization (DiscoPOP)

Extract validation metric

to optimize in outer loop

Offline RLHF

Training

59

60

61

62

63

64

65

66

Win Rate - LC (%)

SLiC

AQL

KTO

DPO

PADLL

AQFL

LRML - DiscoPOP

59.67

60.94

62.76

63.34

64.14

64.41

65.18

Held Out Alpaca Eval Performance

Model Type

Discovered

Baselines

et al., 2023, SLiC], which cast the problem as a supervised learning objective. Many algorithms have been proposed in the literature for offline preference optimization, and it remains an open question which one performs best across tasks. While a strictly dominant algorithm may not exist, some algorithms likely exhibit generally improved performance. To date, all existing state-of-theart preference optimization algorithms [Rafailov et al., 2023, Azar et al., 2023, Zhao et al., 2023] have been developed by human experts. Despite their advancements, these solutions are inherently constrained by human limitations, including creativity, ingenuity, and expert knowledge.

In this work, we aim to address these limitations by performing LLM-driven discovery to automatically generate new state-of-the-art preference optimization algorithms without continual expert human intervention in the development process. While previous works [Ma et al., 2023, Yu et al., 2023] have used LLMs to design environment-specific RL reward functions, we discover general-purpose objective functions which can be used across various preference optimization tasks. More specifically, we iteratively prompt an LLM to propose new preference optimization loss functions and evaluate them, with the previously proposed loss functions and their task performance metric (in our case, MT-Bench scores [Zheng et al., 2024]) as in-context examples. After performing this automatic discovery process, we catalogue high-performing loss functions and introduce a particularly strong one we call Discovered Preference Optimization (DiscoPOP), a new algorithm. To ensure robustness beyond MT-Bench, we validate DiscoPOP using AlapacaEval 2.0 [Dubois et al., 2024], showing an improvement in win rates against GPT-4 from DPO (11 . 23% → 13 . 21%) . Additionally, in separate, held-out, tasks such as summarization and controlled generation, models trained with the DiscoPOP loss outperform or perform competitively with existing preference optimization algorithms.

Contributions: 1 ⃝ We propose an LLM-driven objective discovery pipeline to discover novel offline preference optimization algorithms (Section 3). 2 ⃝ We discover multiple high-performing preference optimization losses. One such loss, which we call Discovered Preference Optimization (DiscoPOP), achieves strong performance across multiple held-out evaluation tasks of multi-turn dialogue (AlpacaEval 2.0), controlled sentiment generation (IMDb) and summarization (TL;DR) tasks. 3 ⃝ We provide an initial analysis of DiscoPOP, which is a weighted sum of logistic and exponential losses, and discover surprising features. For example, DiscoPOP is non-convex.

2 Background

Preference Optimization . Consider a pre-trained language model policy π θ and a dataset D = { ( x i , y i w , y i l ) } N i =1 consisting of prompts x and preference-ranked completions y w and y l . In this dataset, a human rater prefers y w over y l , denoted as y w ≻ y l . The task is to align π θ with the human values implicit in these preferences. Canonically, this has been achieved through reinforcement learning from human feedback [Christiano et al., 2017, RLHF], an approach that proceeds in two

phases: First, a reward modelling stage that learns a parameterized reward model r ϕ . By assuming a Bradley-Terry model [Bradley and Terry, 1952] of preferences, the probability of the data can be expressed as P ( y w ≻ y l ) = exp r ϕ ( y w , x ) / (exp r ϕ ( y w , x ) + exp r ϕ ( y l , x )) , and subsequently simply optimized over ϕ through the maximum likelihood principle. The second stage of policy optimization employs a reinforcement learning algorithm to train the language model against the learned reward. Usually, a KL penalty is introduced between the model and the pre-RL reference policy π ref [Jaques et al., 2019, Stiennon et al., 2020] to prevent over-optimization and straying too far from the original policy, resulting in the final objective:

Despite success in frontier models [Anthropic, 2023, Gemini-Team, 2023], deep RL has many implementations [Engstrom et al., 2019] and training challenges [Sutton, 1984, Razin et al., 2023] that hinder its adoption. To simplify the whole process, direct preference optimization [Rafailov et al., 2023, DPO] aims to forego both the reward modelling and online RL procedure. Rewriting (1) with a decomposition of the KL term into:

expresses the problem as an entropy-regularised RL bandit task [Ziebart et al., 2008], for which a known analytical solution exists: π ∗ ( y | x ) = Z ( x ) -1 π ref ( y | x ) exp ( β -1 r ϕ ( y, x ) ) . By rearranging the reward, we can express the task as a binary classification problem based on the reward difference:

Here, we define the log ratio difference as ρ = log π θ ( y w | x ) π ref ( y w | x ) -log π θ ( y l | x ) π ref ( y l | x ) . In DPO, the function f = -log σ is derived as the negative log of the sigmoid function given the BT model assumptions. However, Tang et al. [2024] highlighted that more generally we can obtain a recipe for offline preference optimization algorithms by letting f : R → R be any scalar loss function. For example, setting f ( x ) = ( x -1) 2 , the squared loss function [Rosasco et al., 2004] yields IPO [Azar et al., 2023], while employing the max-margin inspired hinge loss [Boser et al., 1992, Cortes and Vapnik, 1995] f ( x ) = max(0 , 1 -x ) produces SLiC [Zhao et al., 2023].

Meta-Optimization for Algorithm Discovery . The goal of meta-optimization (optimizing the optimization process) is to uncover novel learning algorithms using a data-driven process. Suppose that an algorithm uses an objective function f γ to train a model for K iterations, where γ denotes a set of meta-parameters. Meta-optimization searches for an objective that maximizes the expected downstream performance max γ E [ η ( π K ) | train ( f γ )] where η is a downstream performance metric. Unlike previous methods that rely on a predefined parameterization of γ (e.g., a neural network [Hospedales et al., 2021] or domain-specific language [Alet et al., 2020]), we leverage LLMs to directly propose code-level objective functions in Python. This approach eliminates the need for a carefully designed search space and utilizes the extensive knowledge embedded in the LLM for flexible selection and mutation.

3 LLM-Driven Objective Discovery

Choosing an appropriate objective function is crucial for instilling capabilities into networks. Here, we detail our discovery process facilitated by LLM code-level objective function proposals:

Initial Context Construction . In the initial system prompt, we 'burn-in' the LLM using several established objective functions given in code and their corresponding performance. Furthermore, we provide problem details and an example of the output response format as a JSON dictionary.

LLM Querying, Parsing & Output Validation . We query the LLM, parse the response JSON, and run a set of unit tests (e.g. for valid output shapes) before starting a training run. If the parsing or unit tests fail, we resample a new solution after providing the error message as feedback to the LLM.

Performance Evaluation . The proposed objective function is then evaluated based on its ability to optimize a model for a predefined downstream validation task. We refer to the resulting performance metric as η .

Iterative Refinement . By using the performance provided as feedback, the LLM iteratively refines its proposals. In each iteration, the model synthesizes a new candidate loss function, exploring both variations of previously successful formulas and entirely new formulations that might improve upon the existing benchmarks. This iterative process is repeated for a specified number of generations or until convergence when a set of optimal loss functions is observed.

We summarise this general objective discovery process in Figure 1 and is shown in Algorithm 1.

Algorithm 1 LLM-Driven Objective Discovery

1: Initialize LLM with established loss functions and their performance in context .

2: repeat for each generation i

3: LLM proposes a new candidate objective function f i

4: Run unit tests to check the validity of the candidate and resample if needed.

5: Evaluate the objective function using the performance metric η

6: Update the LLM context with the performance data

7: LLM refines generation strategy based on the feedback

8: until convergence criteria are met or maximum generations are reached

Small case study: Discovering supervised classification loss functions . Consider the case of supervised classification on the CIFAR-10 dataset as a simple starting example. We train a simple ResNet-18 for 5 epochs using the objectives proposed by GPT-4 [OpenAI, 2023]. After each training run we provide the LLM with the corresponding validation accuracy and query it for the next PyTorch-based [Paszke et al., 2017] candidate objective function.

0

5

10

15

20

25

30

LLM Proposals/Generations

65

70

75

80

Best Accuracy

LLM Objective Discovery - CIFAR-10

Val

Test

ResNet18

SimpleDLA

EfficientNetB0

85

90

95

Test Accuracy

Cross-Entropy

FT - Temp. Scale & Smooth

Hybrid - Smooth & Squared

FT - Hybrid - Smooth & Squared

Cross-Entropy

FT - Temp. Scale & Smooth

Hybrid - Smooth & Squared

FT - Hybrid - Smooth & Squared

Cross-Entropy

FT - Temp. Scale & Smooth

Hybrid - Smooth & Squared

FT - Hybrid - Smooth & Squared

Transfer of Discovered Objective - Models

smoothed

cross

entropy

loss

combined cross

entropy squared

error loss

temperature

scaled cross

entropy loss

finetuned combined

temperature

scaling and label

smoothing loss

Figure 2 depicts the performance of the proposed objective functions across the discovery process. The different discovered objectives all outperform the standard cross-entropy loss. Interestingly, we observe that the LLM-driven discovery alternates between several different exploration, fine-tuning, and knowledge composition steps: Initially, the LLM proposes a label-smoothed cross-entropy objective. After tuning the smoothing temperature, it explores a squared error loss variant, which improved the observed validation performance. Next, the two conceptually different objectives are combined, leading to another significant performance improvement. Hence, the LLM discovery process does not perform a random search over objectives previously outlined in the literature but instead composes various concepts in a complementary fashion. Furthermore, the discovered objectives also generalize to different architectures and longer training runs. In Appendix D.3 we show that this process of discovery is robust to the choice of sampling temperature and prompt/context construction.

4 Discovering Offline Preference Optimization Objectives

In this section, we run our LLM-driven discovery to automatically generate new state-of-the-art preference optimization algorithms.

4.1 Discovery Task - Multi-turn Dialogue on MT-Bench

0

2

4

6

8

10

12

LLM Proposals/Generations

7.7

7.8

7.9

8.0

Best MT-Bench Score

logistic margin loss

combined logistic hinge loss

scaled combined logistic hinge loss

temperature scaled logistic loss

decaying weights logistic loss

performance adaptive decay logistic loss

LLM Objective Discovery - Preference Optimization

0.0

2.5

5.0

7.5

10.0

12.5

15.0

17.5

LLM Proposals/Generations

7.6

7.7

7.8

7.9

8.0

Best MT-Bench Score

smoothed hinge loss

exponential log loss

combined exp logistic loss

adaptive quantile loss

LLM Objective Discovery - Preference Optimization

In this section we use our LLM-driven discovery method to discover new objective functions f for offline preference optimization, as defined in Section 2 and Equation (3). Specifically, at each generation i , GPT-4 generates PyTorch [Paszke et al., 2017] code of candidate objective function f i . Each objective function takes as input the variables of { log π θ ( y w | x ) , log π ref ( y w | x ) , log π θ ( y l | x ) , log π ref ( y l | x ) } , and returns a scalar. For each proposed objective f i , we check if f i is valid with a unit test.

For each valid generated objective function f i , we finetune an LLM and then collect a performance evaluation score. Specifically, we build on top of the 'alignment-handbook' [Tunstall et al., 2023a] repository to finetune our models. Notably, this repository, when using DPO, reproduces 'Zephyr 7B Gemma' 2 Tunstall and Schmid [2024], Tunstall et al. [2023b], which at the time of release, achieved state-of-the-art scores on MT-Bench for 7B models. 'Zephyr 7B Gemma' first takes gemma-7b [Gemma-Team et al., 2024] and finetunes it on the 'deita-10k-v0-sft' dataset [Liu et al., 2023] to produce 'zephyr-7b-gemma-sft' 3 . It is then trained on the pairwise preference dataset of 'Argilla DPO Mix 7K' 4 . When evaluating a new objective function, we replace DPO in this last step with the generated objective function, keeping the same hyperparameters. We show example runs in Figure 12 and provide further experimental details in Appendix B.

Humanities

Extraction

Writing

Roleplay

Reasoning

Math

Coding

Extraction

STEM

Humanities

0

2

4

6

8

10

model

PADLL

LRML

SLiC

DPO

Writing

Roleplay

Reasoning

Math

Coding

0

2

4

6

8

10

model

PADLL

LRML

SLiC

DPO

SFT base model

STEM Once we have a trained LLM for the proposed objective function f i , we evaluate that LLM on the popular multi-turn dialogue evaluation benchmark of MT-Bench [Zheng et al., 2024]. This is a multi-turn open-ended question set, which uses GPT-4 to assess the quality of the trained model's responses, obtaining a high correlation with the popular Chatbot Arena [Zheng et al., 2024]. We provide further evaluation details in Appendix C.

4.2 Discovery Results

After evaluating approximately 100 objective functions, we catalogued the best-performing ones in Table 1. We tabulate the high-level objective forms here and provide the full objective loss functions and their associated code in Appendix E. Moreover, we also plot the best performing sub-task evaluations in Figure 4.

·

·

·

·

SFT base model

5 Held-Out Evaluations

We next validate each of our discovered objective functions (shown in Table 1) on held-out tasks. We find that the Performance Adaptive Decay Loss (PADLL) and the Log Ratio Modulated Loss (LRML) consistently perform well. Because of its unconventional properties and performance, we refer to LRML as our discovered preference optimization, or DiscoPOP , algorithm.

We consider three different standard [Rafailov et al., 2023] open-ended text generation tasks each designed to evaluate different properties of the fine-tuned LLM policy π θ where each LLM policy is trained with one of our discovered objective functions f on a preference dataset D = { ( x i , y i w , y i l ) } N i =1 .

5.1 Single-turn Dialogue - Alpaca Eval 2.0

We evaluate the trained models on Alpaca Eval 2.0, [Li et al., 2023, Dubois et al., 2023, 2024]. This is a single-turn dialogue LLM-based automatic evaluation using GPT-4 to assess the win rate of the trained LLM policy's completion compared to the of the underlying SFT base model. Alpaca Eval 2.0 5 , has been validated against 20K human annotations, and aims to reduce the length bias of Alpaca Eval 1.0; where using length controlled (LC) Alpaca Eval shows a correlation with Chatbot Area of 0.98, making it a popular benchmark with the highest correlation to Chatbot Arena [Dubois et al., 2024]. We also detail task training details in Appendix B.1.

±

±

±

±

We provide the Alpaca Eval 2.0 results in Table 2. As reference policies, we used GPT-4 for absolute comparison and the SFT-trained model for relative comparison. We observe that the discovered LRML (DiscoPOP), PADLL, and AQFL functions outperform the baselines and other discovered losses on the normal and length-controlled win rates. The differences in scores among these topperforming losses are not significant, except for the LC win rate against the SFT reference model, where DiscoPOP performs best.

5.2 Summarization (TL;DR)

We train an LLM policy to, given a forum post on Reddit x , generate a summarization y of the main points. We finetune 'zephyr-7b-gemma-sft' using 10% of the Reddit TL;DR summarization preference dataset [Völske et al., 2017] on each of the baseline and discovered objective functions. As a reference model, we again use 'zephyr-7b-gemma-sft'. Further details on the training pipeline are outlined in Appendix B.2. To evaluate the quality of the summaries, we make use of the Alpaca Eval 2.0 library with a custom evaluation dataset existing of 694 test samples from the TL;DR dataset and a custom GPT-4 annotator template as described in Rafailov et al. [2023]. For additional details regarding the summarization evaluation see Appendix C.3.

In Table 3 the PADLL loss and DPO loss perform best, with little difference from each other, on the summarization task in three out of four metrics. Additionally, the LRML - DiscoPOP function achieves scores slightly below the top performers, especially in the length-controlled win rates. In contrast to the single-turn dialogue task, the AQFL loss does not achieve high scores in the held-out evaluation.

±

±

5.3 Positive sentiment generation (IMDb)

In this task, we train an LLM policy to generate movie review completions y with positive sentiment, where x is a prompt at the start of a movie review from the IMDb dataset [Maas et al., 2011]. We start with a GPT-2 [Radford et al., 2019] model, which had supervised fine-tuning on the IMDb dataset, and we perform preference optimization using the baseline and discovered objective loss functions. Details of the training implementations can be found in Appendix B.3. Inspired by Rafailov et al. [2023]'s experiments, we calculate the model rewards through a pre-trained sentiment classifier, which we use as a proxy for ground truth, as well as the KL-Divergence of the trained model and the reference model. Appendix C.4 provides further details into the evaluation for this task.

We provide results of models with converging β values in Figure 5 for LRML compared against DPO and SLiC, displaying the model rewards against the KL-Divergence to the reference model. In Figure 5a, the LRML-trained text generator outperforms the DPO model in terms of rewards and KL-divergence with low β values (0.025, 0.05, 0.1). At higher β values (0.5 and 1.0) both methods show trends of increased KL-Divergence and lower rewards, but generally, LRML maintains a higher reward than DPO. In Figure 5b, we note that LRML slightly outperforms DPO, SLiC, AQFL, and PADLL at β ∈ { 0 . 05 , 0 . 1 } in terms of reward. For larger β values (0.5 and 1.0), LRML shows similar trends of increased KL-Divergence and rewards like the other objective functions. A more detailed comparison between the individual discovered losses and the baselines can be found in Appendix Figure 8.

6 Analysis of DiscoPOP

We list all our discovered objectives in Table 1, as well as the code and mathematical representations in Appendix E. In this section, we now analyze the Log Ratio Modulated Loss, which we define as the DiscoPOP loss function, as it performs consistently high across the held-out evaluation tasks, and we provide some intuitive understanding of how it outperforms the existing state-of-the-art objectives.

6.1 Log Ratio Modulated Loss (DiscoPOP)

The Log Ratio Modulated Loss is a dynamically weighted sum of the logistic loss (as used in DPO) and the exponential loss. The weight of each is determined through a sigmoid calculation of the

±

±

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: DPO vs LRML

DPO

LRML

(a) DPO vs LRML

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

IMDb Positive Text Generation: All

DPO

SLiC

AQFL

PADLL

LRML

(b) Discovered vs Baseline Losses

difference of log-ratios ( ρ ). Mathematically, the LRML function can be described with a temperature parameter τ = 0 . 05 as follows:

If the difference of log ratios is zero ( ρ = 0) , which is at the start of the training when the model policy π θ is equal to the reference policy π ref, then the loss is equally balanced between the logistic and exponential loss. If ρ →∞ , the model policy diverges from the reference policy and chosen outputs are preferred, then the exponential term dominates. This emphasizes larger differences more strongly. On the other hand, if ρ →-∞ , the model policy diverges from the reference policy, and rejected outputs are preferred. In this case, the logistic loss can handle moderate differences well. The baseline objective losses and the LRML, the PADLL, and the AQFL functions are displayed in Figure 6, including their gradients. Surprisingly, the DiscoPOP function has a non-convex segment and negative gradients at the starting point ρ = 0 . This is potentially helpful for introducing a curriculum or for stochasticity. Additional results and analysis of the discovered loss function can be found in Appendix D.6.

-

10

0

10

20

30

40

Logits

ρ

0.0

0.5

1.0

1.5

Loss

f

(

ρ

)

Discovered Objective Functions

AQFL

PADLL

LRML

DPO

SLiC

-

10

0

10

20

30

40

Logits

ρ

-

0.04

-

0.02

0.00

0.02

0.04

Gradient

f

′

(

ρ

)

Gradient of Objective Functions

AQFL

PADLL

LRML

DPO

SLiC

(a) Discovered Objective Functions

(b) Gradients of the Discovered Objective Functions

6.2 Limitations of DiscoPOP

While performing very well on single-turn text generation and text summarization, we observed during the IMDb experiment that LRML struggles to converge when β is too low ( β ≤ 0 . 01 ) or too high ( β ≥ 2 . 5 ), likely because β = 0 . 05 was never seen or used during the discovery process.

̸

In Figure 9 and Figure 10 of the Appendix, we plot the LRML objective function for β ∈ { 0 . 01 , 0 . 025 , 0 . 05 , 0 . 1 , 0 . 25 , 0 . 5 , 1 , 2 . 5 , 5 } against DPO. When β is high, the DiscoPOP objective function takes the form of the DPO log sigmoid loss. During training on β = 0 . 01 , we observed that DiscoPOP gets stuck in generating predominantly negative reviews (resulting in a reward score of ∼ 0 . 15 ). We hypothesize that the loss is stuck in the local minima to the left with a negative difference in log ratios. While training with β ∈ { 2 . 5 , 5 . 0 } , we observed that the model collapsed after a sharp spike in the loss and subsequently having loss value 0 and NaN outputs. This is potentially due to a large gradient in the non-convex part, which could be amended with gradient clipping.

7 Related Work

Evolution and Search with Large Language Models . LLMs provide a fast and automated way to create multiple candidate solutions for a problem stated in natural language [Song et al., 2024], which makes them powerful tools for driving population-based search procedures. Various recent works have applied this approach to coding problems [Romera-Paredes et al., 2024], neural architecture search [Chen et al., 2024a, Holt et al., 2024b], virtual robotic design settings [Lehman et al., 2023], reward functions [Ma et al., 2023, Yu et al., 2023], and algorithm heuristics [Liu et al., 2024]. Finally, recently LLMs have shown to be capable of acting as recombination operators for black-box optimization with Evolution Strategies [Lange et al., 2024] and for Quality-Diversity approaches [Lim et al., 2024].

Automated Discovery for Machine Learning . There are many other approaches to automating the discovery of generalizable machine learning algorithms. Some prior works explore the space of ML functions using genetic algorithms and a hand-crafted domain-specific language for reinforcement learning algorithms [Co-Reyes et al., 2021], curiosity algorithms [Alet et al., 2020], and optimizers [Chen et al., 2024b]. Other works instead parameterize a transferrable objective function using neural networks and optimize them with evolution strategies or meta-gradients. For example, Lu et al. [2022], Jackson et al. [2024b], Houthooft et al. [2018], Alfano et al. [2024], Kirsch et al. [2019], Oh et al. [2020], Jackson et al. [2024a] discover policy optimization objectives, Metz et al. [2022] evolves neural network optimizers, and Lange et al. [2023b,a] evolve blackbox optimizers. Moreover, automatically discovering closed-form functions (i.e., symbolic regression), works exist that leverage RL [Petersen et al., 2020], gradient descent [Kacprzyk et al., 2024], RL with evolution strategies [Mundhenk et al., 2021], pre-training transformers [Biggio et al., 2021] and hybrid combinations of pre-training transformers, which are further refined with RL and evolution strategies [Holt et al., 2023b].

Preference Optimization Algorithms . While the reduction to supervised learning makes DPO and alternatives easier to use, other approaches have sought to simplify the RL step, including using variants of REINFORCE [Ahmadian et al., 2024, Gemma-Team et al., 2024] as well as more fine-grained feedback [Wu et al., 2024] through preferences over individual steps in the reasoning process [Uesato et al., 2022, Lightman et al., 2023] or reward redistribution [Chan et al., 2024]. Others use iterative offline training interleaved with sampling from the policy model and obtaining a preference ranking from themselves [Xu et al., 2023], another judge LLM [Guo et al., 2024], or an oracle [Swamy et al., 2024].

8 Conclusion

Summary . In this paper, we proposed and used LLM-driven objective discovery to generate novel offline preference optimization algorithms. Specifically, we were able to discover high-performing preference optimization losses that achieve strong performance across held-out evaluation tasks, with the highest performing providing new insights into what an optimal objective may need to possess, such as being a blend of logistic and exponential losses and possibly being non-convex.

Limitations & Future work . There are multiple limitations to our current approach. First, we have only scratched the surface of how to generate LLM objective proposals effectively. Initial exploratory experiments using techniques such as temperature sampling or worst-to-best performance sorting in the context did not yield significant improvements. But one could imagine leveraging more information about the training runs and automatically tuning instruction prompt templates. E.g. by providing entire learning curve plots to a Visual Language Model (see Figure 13) or by meta-metaoptimizing [Lu et al., 2023] the LLM prompt. Second, the highest-performing loss re-purposed β

in the traditional sense, making it affect the functional behavior and the KL penalty of the model with respect to the base model. This motivates future work to study different forms, with perhaps multiple floating point parameters in the form, that each could be tuned separately. Although we provided an initial analysis sweep over this one single parameter and observed some instances of the functional behavior leading to instability of training the model, a further multi-parameter analysis, reformulating the objective, would be beneficial for future work. Finally, our work uses closed-source models (GPT-4) to generate code, which limits reproducibility and is costly to run. Future work could use the produced models themselves to generate code, resulting in code-level self-improvement.

Broader Impact and Ethical Considerations . This paper presents an LLM-driven discovery in-context learning pipeline that is used to generate better-performing novel offline preference optimization algorithms. However, misuse of the pipeline as a tool or training an LLM to produce undesirable, unethical, or harmful outputs could be possible by a user. Furthermore, due to the use of LLMs and training of LLMs, the outputs are susceptible to hallucinations, motivating all outputs of the LLMs to always have a content filter applied to the outputs. Finally, this work takes a small step towards code-level self-improvement in language models, which could potentially result in unintended behaviors.

Acknowledgments and Disclosure of Funding

This work was supported by Azure sponsorship credits granted by Microsoft's AI for Good Research Lab and by Microsoft's Accelerate Foundation Models Academic Research initiative. The hardware used for training was sponsored by GoodAI. SH is funded by AstraZeneca. AJC is funded by a Microsoft Research and EPSRC ICASE scholarship award. CL and RTL were supported by Sakana AI at the time of this work. The code can also be accessed at https://github.com/samholt/ DiscoPOP .

References

Arash Ahmadian, Chris Cremer, Matthias Gallé, Marzieh Fadaee, Julia Kreutzer, Ahmet Üstün, and Sara Hooker. Back to basics: Revisiting reinforce style optimization for learning from human feedback in llms. arXiv preprint arXiv:2402.14740 , 2024.

Ferran Alet, Martin F Schneider, Tomas Lozano-Perez, and Leslie Pack Kaelbling. Meta-learning curiosity algorithms. arXiv preprint arXiv:2003.05325 , 2020.

Carlo Alfano, Sebastian Towers, Silvia Sapora, Chris Lu, and Patrick Rebeschini. Meta-learning the mirror map in policy mirror descent. arXiv preprint arXiv:2402.05187 , 2024.

Anthropic. Model card and evaluations for claude models, 2023. URL https://www-files. anthropic.com/production/images/Model-Card-Claude-2.pdf .

Mohammad Gheshlaghi Azar, Mark Rowland, Bilal Piot, Daniel Guo, Daniele Calandriello, Michal Valko, and Rémi Munos. A general theoretical paradigm to understand learning from human preferences. arXiv preprint arXiv:2310.12036 , 2023.

Luca Biggio, Tommaso Bendinelli, Alexander Neitz, Aurelien Lucchi, and Giambattista Parascandolo. Neural symbolic regression that scales. In International Conference on Machine Learning , pages 936-945. Pmlr, 2021.

Bernhard E Boser, Isabelle M Guyon, and Vladimir N Vapnik. A training algorithm for optimal margin classifiers. In Proceedings of the fifth annual workshop on Computational learning theory , pages 144-152, 1992.

Ralph Allan Bradley and Milton E Terry. Rank analysis of incomplete block designs: I. the method of paired comparisons. Biometrika , 39(3/4):324-345, 1952.

Nicholas Carlini, Florian Tramer, Eric Wallace, Matthew Jagielski, Ariel Herbert-Voss, Katherine Lee, Adam Roberts, Tom Brown, Dawn Song, Ulfar Erlingsson, et al. Extracting training data from large language models. In 30th USENIX Security Symposium (USENIX Security 21) , pages 2633-2650, 2021.

Alex J Chan, Hao Sun, Samuel Holt, and Mihaela van der Schaar. Dense reward for free in reinforcement learning from human feedback. arXiv preprint arXiv:2402.00782 , 2024.

Angelica Chen, David Dohan, and David So. Evoprompting: Language models for code-level neural architecture search. Advances in Neural Information Processing Systems , 36, 2024a.

Xiangning Chen, Chen Liang, Da Huang, Esteban Real, Kaiyuan Wang, Hieu Pham, Xuanyi Dong, Thang Luong, Cho-Jui Hsieh, Yifeng Lu, et al. Symbolic discovery of optimization algorithms. Advances in Neural Information Processing Systems , 36, 2024b.

Paul F Christiano, Jan Leike, Tom Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. Advances in neural information processing systems , 30, 2017.

John D Co-Reyes, Yingjie Miao, Daiyi Peng, Esteban Real, Sergey Levine, Quoc V Le, Honglak Lee, and Aleksandra Faust. Evolving reinforcement learning algorithms. arXiv preprint arXiv:2101.03958 , 2021.

Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine learning , 20:273-297, 1995.

Ganqu Cui, Lifan Yuan, Ning Ding, Guanming Yao, Wei Zhu, Yuan Ni, Guotong Xie, Zhiyuan Liu, and Maosong Sun. Ultrafeedback: Boosting language models with high-quality feedback. arXiv preprint arXiv:2310.01377 , 2023.

Yann Dubois, Xuechen Li, Rohan Taori, Tianyi Zhang, Ishaan Gulrajani, Jimmy Ba, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Alpacafarm: A simulation framework for methods that learn from human feedback, 2023.

Yann Dubois, Balázs Galambosi, Percy Liang, and Tatsunori B Hashimoto. Length-controlled alpacaeval: A simple way to debias automatic evaluators. arXiv preprint arXiv:2404.04475 , 2024.

Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Firdaus Janoos, Larry Rudolph, and Aleksander Madry. Implementation matters in deep rl: A case study on ppo and trpo. In International conference on learning representations , 2019.

Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, and Douwe Kiela. Kto: Model alignment as prospect theoretic optimization, 2024.

Samuel Gehman, Suchin Gururangan, Maarten Sap, Yejin Choi, and Noah A Smith. Realtoxicityprompts: Evaluating neural toxic degeneration in language models. arXiv preprint arXiv:2009.11462 , 2020.

Google DeepMind Gemini-Team. Gemini: A family of highly capable multimodal models, 2023.

Gemma-Team, Thomas Mesnard, Cassidy Hardin, Robert Dadashi, Surya Bhupatiraju, Shreya Pathak, Laurent Sifre, Morgane Rivière, Mihir Sanjay Kale, Juliette Love, et al. Gemma: Open models based on gemini research and technology. arXiv preprint arXiv:2403.08295 , 2024.

Shangmin Guo, Biao Zhang, Tianlin Liu, Tianqi Liu, Misha Khalman, Felipe Llinares, Alexandre Rame, Thomas Mesnard, Yao Zhao, Bilal Piot, et al. Direct language model alignment from online ai feedback. arXiv preprint arXiv:2402.04792 , 2024.

Samuel Holt, Alihan Hüyük, Zhaozhi Qian, Hao Sun, and Mihaela van der Schaar. Neural laplace control for continuous-time delayed systems. In International Conference on Artificial Intelligence and Statistics , pages 1747-1778. PMLR, 2023a.

Samuel Holt, Zhaozhi Qian, and Mihaela van der Schaar. Deep generative symbolic regression. In The Eleventh International Conference on Learning Representations , 2023b. URL https: //openreview.net/forum?id=o7koEEMA1bR .

Samuel Holt, Alihan Hüyük, and Mihaela van der Schaar. Active observing in continuous-time control. Advances in Neural Information Processing Systems , 36, 2024a.

Samuel Holt, Tennison Liu, and Mihaela van der Schaar. Automatically learning hybrid digital twins of dynamical systems. In The Thirty-eighth Annual Conference on Neural Information Processing Systems , 2024b. URL https://openreview.net/forum?id=SOsiObSdU2 .

Samuel Holt, Max Ruiz Luyten, and Mihaela van der Schaar. L2MAC: Large language model automatic computer for extensive code generation. In The Twelfth International Conference on Learning Representations , 2024c. URL https://openreview.net/forum?id=EhrzQwsV4K .

Samuel Holt, Zhaozhi Qian, Tennison Liu, Jim Weatherall, and Mihaela van der Schaar. Datadriven discovery of dynamical systems in pharmacology using large language models. In The Thirty-eighth Annual Conference on Neural Information Processing Systems , 2024d.

Samuel I Holt, Zhaozhi Qian, and Mihaela van der Schaar. Neural laplace: Learning diverse classes of differential equations in the laplace domain. In International Conference on Machine Learning , pages 8811-8832. PMLR, 2022.

Timothy Hospedales, Antreas Antoniou, Paul Micaelli, and Amos Storkey. Meta-learning in neural networks: A survey. IEEE transactions on pattern analysis and machine intelligence , 44(9): 5149-5169, 2021.

Rein Houthooft, Yuhua Chen, Phillip Isola, Bradly Stadie, Filip Wolski, OpenAI Jonathan Ho, and Pieter Abbeel. Evolved policy gradients. Advances in Neural Information Processing Systems , 31, 2018.

Matthew T Jackson, Minqi Jiang, Jack Parker-Holder, Risto Vuorio, Chris Lu, Greg Farquhar, Shimon Whiteson, and Jakob Foerster. Discovering general reinforcement learning algorithms with adversarial environment design. Advances in Neural Information Processing Systems , 36, 2024a.

Matthew Thomas Jackson, Chris Lu, Louis Kirsch, Robert Tjarko Lange, Shimon Whiteson, and Jakob Nicolaus Foerster. Discovering temporally-aware reinforcement learning algorithms. arXiv preprint arXiv:2402.05828 , 2024b.

Natasha Jaques, Asma Ghandeharioun, Judy Hanwen Shen, Craig Ferguson, Agata Lapedriza, Noah Jones, Shixiang Gu, and Rosalind Picard. Way off-policy batch deep reinforcement learning of implicit human preferences in dialog. arXiv preprint arXiv:1907.00456 , 2019.

Krzysztof Kacprzyk, Samuel Holt, Jeroen Berrevoets, Zhaozhi Qian, and Mihaela van der Schaar. ODE discovery for longitudinal heterogeneous treatment effects inference. In The Twelfth International Conference on Learning Representations , 2024. URL https://openreview.net/ forum?id=pxI5IPeWgW .

Louis Kirsch, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Improving generalization in meta reinforcement learning using learned objectives. arXiv preprint arXiv:1910.04098 , 2019.

Robert Lange, Tom Schaul, Yutian Chen, Chris Lu, Tom Zahavy, Valentin Dalibard, and Sebastian Flennerhag. Discovering attention-based genetic algorithms via meta-black-box optimization. In Proceedings of the Genetic and Evolutionary Computation Conference , pages 929-937, 2023a.

Robert Lange, Tom Schaul, Yutian Chen, Tom Zahavy, Valentin Dalibard, Chris Lu, Satinder Singh, and Sebastian Flennerhag. Discovering evolution strategies via meta-black-box optimization. In Proceedings of the Companion Conference on Genetic and Evolutionary Computation , pages 29-30, 2023b.

Robert Tjarko Lange, Yingtao Tian, and Yujin Tang. Large language models as evolution strategies. arXiv preprint arXiv:2402.18381 , 2024.

Joel Lehman, Jonathan Gordon, Shawn Jain, Kamal Ndousse, Cathy Yeh, and Kenneth O Stanley. Evolution through large models. In Handbook of Evolutionary Machine Learning , pages 331-366. Springer, 2023.

Xuechen Li, Tianyi Zhang, Yann Dubois, Rohan Taori, Ishaan Gulrajani, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Alpacaeval: An automatic evaluator of instruction-following models. https://github.com/tatsu-lab/alpaca_eval , 2023.

Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step. In The Twelfth International Conference on Learning Representations , 2023.

Bryan Lim, Manon Flageat, and Antoine Cully. Large language models as in-context ai generators for quality-diversity. arXiv preprint arXiv:2404.15794 , 2024.

Fei Liu, Tong Xialiang, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, and Qingfu Zhang. Evolution of heuristics: Towards efficient automatic algorithm design using large language model. In Forty-first International Conference on Machine Learning , 2024.

Wei Liu, Weihao Zeng, Keqing He, Yong Jiang, and Junxian He. What makes good data for alignment? a comprehensive study of automatic data selection in instruction tuning. arXiv preprint arXiv:2312.15685 , 2023.

Shayne Longpre, Le Hou, Tu Vu, Albert Webson, Hyung Won Chung, Yi Tay, Denny Zhou, Quoc V Le, Barret Zoph, Jason Wei, et al. The flan collection: Designing data and methods for effective instruction tuning. In International Conference on Machine Learning , pages 22631-22648. PMLR, 2023.

Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations , 2017. URL https://api.semanticscholar.org/ CorpusID:53592270 .

Chris Lu, Jakub Kuba, Alistair Letcher, Luke Metz, Christian Schroeder de Witt, and Jakob Foerster. Discovered policy optimisation. Advances in Neural Information Processing Systems , 35:1645516468, 2022.

Chris Lu, Sebastian Towers, and Jakob Foerster. Arbitrary order meta-learning with simple populationbased evolution. In ALIFE 2023: Ghost in the Machine: Proceedings of the 2023 Artificial Life Conference . MIT Press, 2023.

Yecheng Jason Ma, William Liang, Guanzhi Wang, De-An Huang, Osbert Bastani, Dinesh Jayaraman, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Eureka: Human-level reward design via coding large language models. arXiv preprint arXiv:2310.12931 , 2023.

Andrew Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th annual meeting of the association for computational linguistics: Human language technologies , pages 142-150, 2011.

Luke Metz, James Harrison, C Daniel Freeman, Amil Merchant, Lucas Beyer, James Bradbury, Naman Agrawal, Ben Poole, Igor Mordatch, Adam Roberts, et al. Velo: Training versatile learned optimizers by scaling up. arXiv preprint arXiv:2211.09760 , 2022.

T Nathan Mundhenk, Mikel Landajuela, Ruben Glatt, Claudio P Santiago, Daniel M Faissol, and Brenden K Petersen. Symbolic regression via neural-guided genetic programming population seeding. In Proceedings of the 35th International Conference on Neural Information Processing Systems , pages 24912-24923, 2021.

Junhyuk Oh, Matteo Hessel, Wojciech M Czarnecki, Zhongwen Xu, Hado P van Hasselt, Satinder Singh, and David Silver. Discovering reinforcement learning algorithms. Advances in Neural Information Processing Systems , 33:1060-1070, 2020.

OpenAI. Gpt-4 technical report, 2023.

Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.

Brenden K Petersen, Mikel Landajuela Larma, Terrell N Mundhenk, Claudio Prata Santiago, Soo Kyung Kim, and Joanne Taery Kim. Deep symbolic regression: Recovering mathematical expressions from data via risk-seeking policy gradients. In International Conference on Learning Representations , 2020.

Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog , 1(8):9, 2019.

Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D Manning, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. arXiv preprint arXiv:2305.18290 , 2023.

Noam Razin, Hattie Zhou, Omid Saremi, Vimal Thilak, Arwen Bradley, Preetum Nakkiran, Joshua Susskind, and Etai Littwin. Vanishing gradients in reinforcement finetuning of language models. arXiv preprint arXiv:2310.20703 , 2023.

Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Matej Balog, M Pawan Kumar, Emilien Dupont, Francisco JR Ruiz, Jordan S Ellenberg, Pengming Wang, Omar Fawzi, et al. Mathematical discoveries from program search with large language models. Nature , 625(7995):468-475, 2024.

Lorenzo Rosasco, Ernesto De Vito, Andrea Caponnetto, Michele Piana, and Alessandro Verri. Are loss functions all the same? Neural computation , 16(5):1063-1076, 2004.

Xingyou Song, Yingtao Tian, Robert Tjarko Lange, Chansoo Lee, Yujin Tang, and Yutian Chen. Position paper: Leveraging foundational models for black-box optimization: Benefits, challenges, and future directions. arXiv preprint arXiv:2405.03547 , 2024.

Nisan Stiennon, Long Ouyang, Jeffrey Wu, Daniel Ziegler, Ryan Lowe, Chelsea Voss, Alec Radford, Dario Amodei, and Paul F Christiano. Learning to summarize with human feedback. Advances in Neural Information Processing Systems , 33:3008-3021, 2020.

Richard Stuart Sutton. Temporal credit assignment in reinforcement learning . University of Massachusetts Amherst, 1984.

Gokul Swamy, Christoph Dann, Rahul Kidambi, Zhiwei Steven Wu, and Alekh Agarwal. A minimaximalist approach to reinforcement learning from human feedback. arXiv preprint arXiv:2401.04056 , 2024.

Yunhao Tang, Zhaohan Daniel Guo, Zeyu Zheng, Daniele Calandriello, Rémi Munos, Mark Rowland, Pierre Harvey Richemond, Michal Valko, Bernardo Ávila Pires, and Bilal Piot. Generalized preference optimization: A unified approach to offline alignment. arXiv preprint arXiv:2402.05749 , 2024.

Lewis Tunstall and Philipp Schmid. Zephyr 7b gemma. https://huggingface.co/ HuggingFaceH4/zephyr-7b-gemma-v0.1 , 2024.

Lewis Tunstall, Edward Beeching, Nathan Lambert, Nazneen Rajani, Shengyi Huang, Kashif Rasul, Alexander M. Rush, and Thomas Wolf. The alignment handbook. https://github.com/ huggingface/alignment-handbook , 2023a.

Lewis Tunstall, Edward Beeching, Nathan Lambert, Nazneen Rajani, Kashif Rasul, Younes Belkada, Shengyi Huang, Leandro von Werra, Clémentine Fourrier, Nathan Habib, Nathan Sarrazin, Omar Sanseviero, Alexander M. Rush, and Thomas Wolf. Zephyr: Direct distillation of lm alignment, 2023b.

Jonathan Uesato, Nate Kushman, Ramana Kumar, Francis Song, Noah Siegel, Lisa Wang, Antonia Creswell, Geoffrey Irving, and Irina Higgins. Solving math word problems with process-and outcome-based feedback. arXiv preprint arXiv:2211.14275 , 2022.

Michael Völske, Martin Potthast, Shahbaz Syed, and Benno Stein. Tl; dr: Mining reddit to learn automatic summarization. In Proceedings of the Workshop on New Frontiers in Summarization , pages 59-63, 2017.

Leandro von Werra, Younes Belkada, Lewis Tunstall, Edward Beeching, Tristan Thrush, and Nathan Lambert. TRL: Transformer Reinforcement Learning. URL https://github.com/ huggingface/trl .

Zeqiu Wu, Yushi Hu, Weijia Shi, Nouha Dziri, Alane Suhr, Prithviraj Ammanabrolu, Noah A Smith, Mari Ostendorf, and Hannaneh Hajishirzi. Fine-grained human feedback gives better rewards for language model training. Advances in Neural Information Processing Systems , 36, 2024.

Jing Xu, Andrew Lee, Sainbayar Sukhbaatar, and Jason Weston. Some things are more cringe than others: Preference optimization with the pairwise cringe loss. arXiv preprint arXiv:2312.16682 , 2023.

Wenhao Yu, Nimrod Gileadi, Chuyuan Fu, Sean Kirmani, Kuang-Huei Lee, Montse Gonzalez Arenas, Hao-Tien Lewis Chiang, Tom Erez, Leonard Hasenclever, Jan Humplik, et al. Language to rewards for robotic skill synthesis. arXiv preprint arXiv:2306.08647 , 2023.

Yao Zhao, Rishabh Joshi, Tianqi Liu, Misha Khalman, Mohammad Saleh, and Peter J Liu. Slic-hf: Sequence likelihood calibration with human feedback. arXiv preprint arXiv:2305.10425 , 2023.

Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems , 36, 2024.

Zhanhui Zhou, Zhixuan Liu, Jie Liu, Zhichen Dong, Chao Yang, and Yu Qiao. Weak-to-strong search: Align large language models via searching over small language models. arXiv preprint arXiv:2405.19262 , 2024.

Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, Anind K Dey, et al. Maximum entropy inverse reinforcement learning. In Aaai , volume 8, pages 1433-1438. Chicago, IL, USA, 2008.

Appendix

Table of Contents

A LLM-Driven Objective Discovery Implementation Details

A.1 Prompts

We use the following system prompt to generate the model responses:

We then provide the first user prompt as such:

Upon testing the generated code, if an error is encountered, we provide the following prompt, where 'error' is the text containing the system error:

Upon successful completion, we return the following user prompt, where 'val' is the MT-Bench score:

B Training Details

B.1 Discovery Task - Single-turn Dialogue

For each valid generated objective function f i , we use it to train an LLM and then collect a performance evaluation score. Specifically, we follow the same process when training and evaluating all objective functions, starting with a pre-trained supervised fine-tuned (SFT) 7 billion gemma model of 'zephyr-7b-gemma-sft' This is a 7 billion base version gemma [Gemma-Team et al., 2024] model supervised-fine-tuned on the 'deita-10k-v0-sft' dataset [Liu et al., 2023]. Starting with this model, we train it on the pairwise preference dataset of 'Argilla DPO Mix 7K'; which attempts to create a high-quality preference dataset by filtering only highly rated chosen responses from the datasets of a multi-turn dataset, instruction following dataset [Longpre et al., 2023] and a diverse preference dataset that covers truthfulness, honesty and helpfulness [Cui et al., 2023]. For each training run, we trained all the parameters of the starting model, using a fixed β = 0 . 05 . We used the same fixed hyper-parameters for all training runs unless explicitly noted. Specifically, we used a learning rate of 5e-7, bfloat16 floating-point format, two epochs, a batch size per device of two, a gradient accumulation step of 8, a cosine learning rate scheduler, and AdamW optimization algorithm [Loshchilov and Hutter, 2017]. We use the popular TRL transformers library [von Werra et al.], adapting the offline preference optimization objective function to train all models. The models were trained on 8 Nvidia A100 GPUs. An individual training run takes approximately 30 minutes. We provide training and evaluation statistics for discovered objective functions in Figure 7. We also provide the equivalent code implementation at https://github.com/vanderschaarlab/DiscoPOP .

B.2 TL;DR Summarization

To determine if the discovered objective functions generalize well also to other tasks, we use them to preference optimize an LLM for text summarization. Specifically, we start again with a pre-trained supervised fine-tuned (SFT) 7 billion gemma model of 'zephyr-7b-gemma-sft', and we optimized it with the objective function f i on a subsample of the Reddit TL;DR summarization preference dataset

0

20

40

60

80

100

Train Step

0.2

0.4

0.6

0.8

1.0

Loss

Train and Eval Loss

DPO

PADLL

LRML

SLiC

Final Eval Loss

(a) Loss

0

20

40

60

80

100

Train Step

0.0

0.2

0.4

0.6

0.8

Reward Accuracy

DPO

PADLL

LRML

SLiC

Final Eval Accuracy

(b) Accuracy

[Völske et al., 2017] 6 . More precisely we use the first 10% of the dataset for preference optimization, which amounts to around 8'000 training samples. During training the hyperparameters are kept the same as in the single-turn dialogue task, explained in subsection B.1, except that LLMs were trained 4 Nvidia A100 GPUS using a gradient accumulation step of 16. An individual training run takes approximately 1.5 hours.

B.3 IMDb Positive Text Generation

Another popular generalization task for preference optimization [Rafailov et al., 2023] is to fine-tune a small LLM to generate positive text for movie review, based on the IMDb sentiment dataset [Maas et al., 2011] 7 following the the work of Zhou et al. [2024]. As a starting model, we use a GPT2 model [Radford et al., 2019], that was supervised fine-tuned on the IMDb dataset 8 . Subsequently, we apply the baseline and discovered objective function f i for preference optimization. The goal of the LLM is to give a short prompt of 2-8 tokens, which indicate the start of a movie review, to generate a positive review. As we are interested in the effect of β on the rewards and KL-Divergence, we train the objective functions over a sweep of β ∈ { 0 . 01 , 0 . 025 , 0 . 05 , 0 . 1 , 0 . 25 , 0 . 5 , 1 , 2 . 5 , 5 } . Every LLM is trained for three epochs, using the AdamW optimizer, with an initial learning rate of 5.0e-5, a warm-up scheduler of 0.1, and a cosine learning rate scheduler. The models are trained on 4 Nvidia A100 GPUs, using a gradient accumulation step of 8, and a batch size per device of 2. The training takes around 30 minutes.

C Evaluation Metrics

C.1 MT-Bench

To assess the fitness of the discovered preference optimization loss function during the discovery phase, we evaluate the trained LLMs on the MT-Bench [Zheng et al., 2024] benchmark. The evaluation benchmark consists of 80 high-quality multi-turn questions from various disciplines. The goal is to assess LLM's ability to follow instructions and keep the flow of a conversation. A larger LLM, in our case GPT-4, is then used as a judge to score the quality of the answers with a number from 0 (lowest) to 10 (highest). Scores are given based on the quality of the LLM's first-turn answer (single-turn) and first and second answers (multi-turn). Finally, the MT-Bench score is the average

of single-turn and multi-turn scores. For answer generation and evaluation, we used the FastChat library 9 and its standard sampling and temperature parameters, provided by Zheng et al. [2024].

C.2 Alpaca Eval

Alpaca Eval 2.0 [Li et al., 2023, Dubois et al., 2023, 2024] is also a popular benchmark for evaluating LLMs. This is a single-turn dialogue LLM-based automatic evaluation using a stronger LLM, here GPT-4 Turbo, to assess the win rate of the trained LLM policy's completion compared to either GPT-4 or the of the underlying SFT base model. Specifically, Alpaca Eval 2.0 has been validated against 20K human annotations and aims to reduce the length bias of Alpaca Eval, where using length-controlled (LC) Alpaca Eval shows a correlation with Chatbot Arena of 0.98, making it a popular benchmark with the highest correlation to Chatbot Arena [Dubois et al., 2024]. The Alpaca evaluation dataset consists of 841 high-quality instructions from different data sets. The library 10 provided by Dubois et al. [2024] calculates the win-rate (percentage were the trained policy is prefered over the reference policy, first introduced in Alpaca Eval 1.0), and a length-controlled win-rate, where a linear model is fitted to de-bias for length of the prompt and instruction difficulty. We used a temperature of 0.7, sampling, and a maximum number of new tokens of 1024 to generate the answers. Furthermore, the library provides the standard error of the mean, which indicates the confidence of the win-rate and LC win-rate.

C.3 TL;DR Summarization Win-Rate

To evaluate how well the discovered objective functions generalize to the summarization task, we use the Alpaca Eval 2.0 library, similar to subsection C.2. Instead of using the Alpaca evaluation dataset, we create a custom dataset of 694 samples from the IMDb preference test dataset. Additionally, we change the prompt of the annotator LLM, to fit the "Summarization GPT-4 win rate prompt (C)" as described in Rafailov et al. [2023]. The (LC) win-rate is calculated against either the existing human-chosen test sample or against the summary generated by the SFT reference model. For a summary generation, we apply a temperature parameter of 0.7, sampling, and a maximum of 256 new tokens. Moreover, we stop the summarization after the "\n" token to avoid nonsensical generations. Furthermore, as we cannot calculate an instruction difficulty for the length-controlled win-rate, we omit this term from the linear model (This has only a small impact on the metric). In addition to the win-rates we also provide the standard error as a measure of confidence.

C.4 IMDb Rewards vs KL-Divergence

For the positive text generation, we do not require an LLM judge compared to MT-Bench, Alpaca Eval 2.0, and TL;DR evaluation, as we take a pre-trained sentiment classifier 11 as ground truth reward scorer. The LLMs apply sampling and a maximum of 60 new tokens for the positive text generation. The rewards and KL-divergence are averaged over 10 different generations from the trained LLMs.

D Additional Results

D.1 Frontiers of Expected Reward vs KL Divergence

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: DPO vs LRML

DPO

LRML

(a) SLiC vs LRML

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: SLiC vs LRML

SLiC

LRML

(b) SLiC vs LRML

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: DPO vs PADLL

DPO

PADLL

(c) DPO vs PADLL

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: SLiC vs PADLL

SLiC

PADLL

(d) SLiC vs PADLL

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: DPO vs AQFL

DPO

AQFL

(e) DPO vs AQFL

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

KL Divergence

0.86

0.88

0.90

0.92

0.94

0.96

0.98

Reward

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

β

=0.025

β

=0.05

β

=0.1

β

=0.25

β

=0.5

β

=1.0

IMDb Positive Text Generation: SLiC vs AQFL

SLiC

AQFL

(f) SLiC vs AQFL

D.2 Loss Sweeps for Different Beta Parameters

-

20

0

20

40

Logits

ρ

0.5

0.6

0.7

0.8

Loss

f

(

ρ

)

β

=0.01

DPO

LRML

-

20

0

20

40

Logits

ρ

0.4

0.6

0.8

1.0

Loss

f

(

ρ

)

β

=0.025

DPO

LRML

-

20

0

20

40

Logits

ρ

0.2

0.4

0.6

0.8

1.0

1.2

Loss

f

(

ρ

)

β

=0.05

DPO

LRML

-

20

0

20

40

Logits

ρ

0.0

0.5

1.0

1.5

2.0

Loss

f

(

ρ

)

β

=0.1

DPO

LRML

-

20

0

20

40

Logits

ρ

0

1

2

3

4

5

Loss

f

(

ρ

)

β

=0.25

DPO

LRML

-

20

0

20

40

Logits

ρ

0

2

4

6

8

10

Loss

f

(

ρ

)

β

=0.5

DPO

LRML

-

20

0

20

40

Logits

ρ

0

5

10

15

20

Loss

f

(

ρ

)

β

=1

DPO

LRML

-

20

0

20

40

Logits

ρ

0

10

20

30

40

50

Loss

f

(

ρ

)

β

=2.5

DPO

LRML

-

20

0

20

40

Logits

ρ

0

20

40

60

80

100

Loss

f

(

ρ

)

β

=5

DPO

LRML

Comparison of DPO vs LRML for different

β

Values

Comparison of DPO vsLRML Gradients for Different β Values

-

20

0

20

40

Logits

ρ

-

0.0075

-

0.0050

-

0.0025

0.0000

0.0025

0.0050

0.0075

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.01

DPO

LRML

-

20

0

20

40

Logits

ρ

-

0.02

-

0.01

0.00

0.01

0.02

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.025

DPO

LRML

-

20

0

20

40

Logits

ρ

-

0.04

-

0.02

0.00

0.02

0.04

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.05

DPO

LRML

-

20

0

20

40

Logits

ρ

-

0.05

0.00

0.05

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.1

DPO

LRML

-

20

0

20

40

Logits

ρ

-

0.2

-

0.1

0.0

0.1

0.2

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.25

DPO

LRML

-

20

0

20

40

Logits

ρ

-

0.4

-

0.2

0.0

0.2

0.4

Loss Gradient

∇

ρ

f

(

ρ

)

β

=0.5

DPO

LRML

-

20

0

20

40

Logits

ρ

-

1.0

-

0.5

0.0

0.5

Loss Gradient

∇

ρ

f

(

ρ

)

β

=1

DPO

LRML

-

20

0

20

40

Logits

ρ

-

2

-

1

0

1

2

Loss Gradient

∇

ρ

f

(

ρ

)

β

=2.5

DPO

LRML

-

20

0

20

40

Logits

ρ

-

4

-

2

0

2

4

Loss Gradient

∇

ρ

f

(

ρ

)

β

=5

DPO

LRML

D.3 Discovery Robustness with respect to LLM Hyperparameters

CIFAR-10 ObjectiveDiscovery

CIFAR-10 ObjectiveDiscovery

CIFAR-10ObjectiveDiscovery

TemperatureSettings

Context Content/Sorting

ContextValidExamples&Thought

ValidationAccuracy

80

75

Temp: 0.1

Include Thought - Only Valid

70

Temp: 0.5

No Sort-Top 5

No Thought - Only Valid

Temp: 1

No Sort -Top 10

Include Thought - AlI

No Thought - All

65

0

5

10

15

0

5

10

15

0

5

10

15

LLMProposals/Generations

LLMProposals/Generations

LLMProposals/Generations

D.4 LLM-Driven Discovery Analysis

LLM Objective Discovery-CIFAR-10

82.5

80.0

Best Accuracy

77.5

weighted_combined_loss

fnetuned_oobined_loss

75.0

combined_oross_entropy_squared_emror_loss

72.5

70.0

67.5

Val

65.0

smoosmosenropy_.ss

ed_error_loss

Test

0

5

10

15

LLMProposals/Generations

Nofitnessfeedback-CIFAR-10

82.5

80.0

BestAccuracy

77.5

75.0

72.5

70.0

67.5

Val

Test

65.0

oArudooum

cross_ertropy_loss

0

5

10

15

LLMProposals/Generations

D.5 Visual Language Models for Objective Discovery

VLM-Driven Discovery

VLMvs.LLMDiscovery-CIFAR-10

92

Extend/Update

researcher who is testing out different

loSs functionS.<PROBLEM DESCRIPTION>

SYSTEM PRoMPT: You are a nachine learning

BestAccuracy

91

Context & Fitness

1<QuERY>:Propose the next one to

1FORMAT>}

Here is an example: {<EXAMPLE JSON

90

ropyo

VLM-Val

performance and learning curve plot.

evaluate. - Add evals, validation

LLM-Val

89

VLM-Test

CODE-LEVEL JSON FOUNDATION MODEL PROPOSAL:

LLM-Test

Visual Language

{"thought": “Based on the previous outputs, ...",

"name": "cross_entropy_loss",

code":"def loss_fn(

88

0

5

10

15

20

ModelProposal

targets: torch.FloatTensor

logits: torch.FloatTensor,

V/LLMProposals/Generations

）→ torch.FloatTensor:

loss = F.cross_entropy(logits, targets)

return loss*}

INNER LOOP EVALUATION OF PROPOSED OBJECTIVE:

Training with Proposed Objective

Offline

RLHF

Run + Visualize

Extract validation metric!

to optinize in outer loop

7.5

10.9

125 15017.5

7.5

10.0

lpoch

125 15.017.5

D.6 Additional Analysis of DiscoPOP

We performed further analysis to improve our understanding of the discovered loss function. We hypothesize that the local optimum of the DiscoPOP loss could catch noisy or incorrect data points. By inspecting the DiscoPOP loss values and log ratios of the training preference pairs in the IMDb dataset, we see that 1.35% of training points fall there (see Figure 14). Although we use the binary preference labels from the IMDb dataset 12 for training, the dataset also includes a positivity reward score for each completion, calculated by a separate reward model. When we analyze the data points between the local optima, we find that the positive and negative completions are significantly closer in absolute reward difference than those outside the local optimum (See Table 4). This implies that the preference labels on those points are likely more challenging to distinguish and help empirically validate our hypothesis.

IMDb Training Logits Distribution and Loss

Above local maximum (92.43%)

0OE

Between optima (1.35%)

Below local minimum (6.22%)

250

200

Count

150

100

50

-5.0

2.5

0.0

2.5

Difference of Log-Ratios

5.0

7.5

10.0

12.5

E Discovered Objective Functions

To describe the discovered losses mathematically, we define three existing preference optimization losses here:

Moreover, we display the code of the discovered losses as it is output by the LLM. In addition, we provide a mathematical representation of each, which we have adapted to be consistent with β being the KL-Divergence regularization parameter. This is because the generated code for LRML, DBAQL, AQL, AQFL, and PFL did not uphold the β ought to be multiplied with the difference of log-ratios before any further calculations. If this was not upheld, it could lead to the loss function changing shapes based on the KL-regularization term, and therefore, models could not converge or potentially collapse. In future work, we should constrain the exploring LLM to uphold the β multiplication with the input before any other calculations are done with the difference of log-ratios ρ . As the meta-exploration was done with a set β = 0 . 05 , and we wish to keep consistent with this scale of regularization, we have adapted the losses by dividing ρ values used in intermediate calculations with a scalar τ = 0 . 05 .

In the IMDb experiment in Section 5, we have thus used the corrected version of codes for the discovered losses based on the provided mathematical representation, as we were most interested in the effect of the KL-divergence compared to the model rewards.

E.1 DBAQL: Dynamic Blended Adaptive Quantile Loss

MT-Bench Score: 7.978

E.2 AQL: Adaptive Quantile Loss

MT-Bench Score: 7.953

E.3 PADLL: Performance Adaptive Decay Logistic Loss

MT-Bench Score: 7.941

This loss can also be rewritten as:

E.4 AQFL: Adaptive Quantile Feedback Loss

MT-Bench Score: 7.931

E.5 CELL: Combined Exponential + Logistic Loss

MT-Bench Score: 7.925

E.6 LRML: Log Ratio Modulated Loss

MT-Bench Score: 7.916

E.7 PFL: Policy Focused Loss

MT-Bench Score: 7.900

Interestingly, the PFL generated function code did not include any β values in the loss function. We have added it to the corrected code for the IMDb experiment, as well as to the mathematical expression below. We account for the consistency of the logit values by dividing with τ = 0 . 05 , which is the same value as β in the discovery process.

F Extended Related Work

In the following, we provide an extended related work of the related work included in the main paper.

Evolution and Search with Large Language Models . LLMs provide a fast and automated way to create multiple candidate solutions for a problem stated in natural language [Song et al., 2024], which makes them powerful tools for driving population-based search procedures. Various recent works have applied this approach to coding problems [Romera-Paredes et al., 2024], neural architecture search [Chen et al., 2024a, Holt et al., 2024b,d], virtual robotic design settings [Lehman et al., 2023], reward functions [Ma et al., 2023, Yu et al., 2023], and algorithm heuristics [Liu et al., 2024]. Finally, recently LLMs have shown to be capable of acting as recombination operators for black-box optimization with Evolution Strategies [Lange et al., 2024] and for Quality-Diversity approaches [Lim et al., 2024]. Additionally, prior work has shown LLM multi-agent frameworks' ability to excel at large code-generation tasks [Holt et al., 2024c], which we could envision enabling scaling up searching for larger candidate solutions for more complicated objectives or algorithms than the existing approaches that fit within the LLMs output context window.

Automated Discovery for Machine Learning . There are many other approaches to automating the discovery of generalizable machine learning algorithms. Some prior works explore the space of ML functions using genetic algorithms and a hand-crafted domain-specific language for reinforcement learning algorithms [Co-Reyes et al., 2021], curiosity algorithms [Alet et al., 2020], and optimizers [Chen et al., 2024b]. Other works instead parameterize a transferrable objective function using neural networks and optimize them with evolution strategies or meta-gradients. For example, Lu et al. [2022], Jackson et al. [2024b], Houthooft et al. [2018], Alfano et al. [2024], Kirsch et al. [2019], Oh et al. [2020], Jackson et al. [2024a] discover policy optimization objectives, Metz et al. [2022] evolves neural network optimizers, and Lange et al. [2023b,a] evolve blackbox optimizers. Moreover, automatically discovering closed-form functions (i.e., symbolic regression), works exist that leverage RL [Petersen et al., 2020], gradient descent [Kacprzyk et al., 2024], RL with evolution strategies [Mundhenk et al., 2021], pre-training transformers [Biggio et al., 2021] and hybrid combinations of pre-training transformers, which are further refined with RL and evolution strategies [Holt et al., 2023b]. Furthermore, more general-purpose ML approaches exist to perform sequential modeling of

processes [Holt et al., 2022], which can be readily used in model-based RL approaches [Holt et al., 2023a, 2024a].

Preference Optimization Algorithms . While the reduction to supervised learning makes DPO and alternatives easier to use, other approaches have sought to simplify the RL step, including using variants of REINFORCE [Ahmadian et al., 2024, Gemma-Team et al., 2024] as well as more fine-grained feedback [Wu et al., 2024] through preferences over individual steps in the reasoning process [Uesato et al., 2022, Lightman et al., 2023] or reward redistribution [Chan et al., 2024]. Others use iterative offline training interleaved with sampling from the policy model and obtaining a preference ranking from themselves [Xu et al., 2023], another judge LLM [Guo et al., 2024], or an oracle [Swamy et al., 2024].

G Full Run Log

We provide a full run below, formatted for readability.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: Please see Sections 2-8.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: We discuss limitations in Section 8 under the heading Limitations & Future Work

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [NA]

Justification: We do not include theoretical results.

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: We provide details on all our experiments in the main paper and appendix, as well as providing code for reproducing them at https://github.com/samholt/ DiscoPOP .

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: We provide code for reproducing results at https://github.com/samholt/ DiscoPOP .

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Details are given in Sections 4, 5, and 6.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: We provide details on standard errors in the results tables.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: Details are given in Appendix B.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: We reviewed the NeurIPS Code of Ethics and ensured the research conforms to it.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [Yes]

Justification: We discuss this in Section 8 under the heading Broader Impact and Ethical Considerations .

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: The paper poses no such risk.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: All creators are properly credited.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [NA]

Justification: The paper does not release new assets.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: The paper does not involve crowdsourcing nor research with human subjects. Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: The paper does not involve crowdsourcing nor research with human subjects. Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper introduces a method of searching for offline RL objectives by using LLMs to generate and refine objectives. They demonstrate that several objectives discovered using this method are able to achieve higher evaluation scores than existing objectives (e.g. DPO) on a variety of benchmark tests. They provide a high level analysis of one discovered objective, hypothesizing that it may possess desirable properties that lead to these performance boosts.\n\nSTRENGTHS:\nThe paper is well written, organized, and easy to understand. While the use of LLMs to modify prompts and self-improve in other ways has been studied, using them to improve objective functions is a novel idea that the authors demonstrate holds potential. The authors demonstrate that the objectives discovered can be useful, showing improvements on a variety of generation and classification tasks.\n\nWEAKNESSES:\nThe main weakness of this paper in my opinion is that it isn't clear what results the paper is trying to present. While this is partially an issue of organization, it is also an issue with the amount of evidence given to the claims in the paper. If these was made clearer, I would be inclined to raise my score. I detail below:\n\n1. The paper starts by introducing a new method for discovering new optimization objectives using LLMs, then transitions quite abruptly to describing the properties of DiscoPop. While both could be valuable contributions, I don't feel that either is given quite the attention required. It would help to clarify what the main focus of the paper is. If DiscoPOP is the focus, then claims about its properties should be better studied. If the discovery method is the focus, more emphasis should be placed on the method's performance and ability to produce novel and useful objectives.\n\n2. The majority of insights about DiscoPOP are presented as hypotheses or intuitive insights (e.g. the non-convex portion, and how the model behaves at $\\pm\\inf$. This is not enough to support the claim made in the conclusion that they provide insights into what properties an optimal objective function should possess. While it \\emph{may} be enough to say the provide intuition into why DiscoPOP is successful, further experimentation would be necessary to make optimality claims like this.\n\n3. Some portions of the discovery method are vague as well. Though the authors do not observe the models simply regurgitating old objectives and cite a pattern of objective refinement for supervised learning, this is of course not guaranteed, and not well studied. Further experiments or details on the how often they observe refinement vs regurgitation would help to support the utility of the method.\n\nQUESTIONS:\n1. How often are unit tests for the generated code failed?\n\nLIMITATIONS:\nThe limitations described cover most points, including the difficulties and uncertainties associated with using LLMs to improve upon objectives in a rigorous fashion.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-13"}

comments: SUMMARY:
The paper proposes DiscoPOP, an algorithm for discovering preference optimization loss functions using Large Language Models (LLMs). The authors propose an LLM-driven objective discovery process by iterative prompting LLMs by previously evaluated performance metrics. Experiments on various benchmarks demonstrate its effectiveness.

STRENGTHS:
1. This method is innovative. The idea of updating the loss function through automated exploration is both interesting and novel. The process being fully automated and end-to-end makes it particularly neat.
2. The results are impressive. DiscoPOP demonstrates strong performance across various benchmarks, showing its potential.

WEAKNESSES:
I think the updating process might be sensitive to the prompts used for proposing new loss functions.

QUESTIONS:
Refer to the weakness

LIMITATIONS:
Refer to the weakness
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-13

comments: SUMMARY:
The paper proposes an algorithm to discover preference objective functions using LLM for LLM preference optimization. Authors conduct experiments with the discovered objectives on multiple datasets and demonstrate that the discovered objective functions generally perform better than baselines. The authors also show interesting insight into the discovered objective function, LRML.

STRENGTHS:
1. The paper introduces an interesting and new LLM-driven objective discovery algorithm to search for good objective functions using LLMs for the preference optimization of LLMs.
2. The method successfully finds an objective function that can generally offer a better performance on multiple benchmarks, indicating the effectiveness of the discovery method.
3. The authors show interesting insights into the best objective function found by the proposed method.

WEAKNESSES:
1. The objective function is discovered with a different placement of $\beta$ than the objective function used for evaluation, which causes a misalignment of the discovery and the evaluation process. It would be nice to keep them aligned.
2. The LLM in the discovery process is a clever generator for searching candidates. It is unclear if the LLM's capability used in the discovery process can change the duration for finding a good objective function or if it will cause the search process to fail.
3. Similar to the point above, it would be nice to test some non-LLM-based generators of the objective function and perform some traditional searching algorithms such as evolutionary search to demonstrate the effectiveness of the LLM.

QUESTIONS:
See weakness above.

LIMITATIONS:
See weakness above.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-15

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes a novel approach to improving LLMs by using an automated system to discover new optimization algorithms. Traditionally, enhancing LLMs has relied heavily on hand-designed loss functions, but this research employs an LLM to iteratively generate and refine these functions itself. This paper introduced DiscoPOP, which blends logistic and exponential losses to outshine existing methods. This algorithm was evaluated across a range of tasks, including multiturn dialogue, sentiment generation, and summarization, where it consistently delivered good results.\n\nSTRENGTHS:\n- The automatic exploration and evaluation pipeline is promising and it can discover new algorithms without human intervention.\n- By using the above pipeline, the new discovered algorithm in preference optimization achieved SOTA, proving its effectiveness.\n- This can contribute to lots of other area and let machines themselves to discover and evaluate new efficent algorithms.\n\nWEAKNESSES:\nAlthough this paper mianly focuses on preference optimization task, the dicovery method seems to be easily to adapt to other domains/tasks. A general concern with the paper is its reliance on a complex method that involves detailed tuning of hyperparameters. This complexity could limit the method's broader applicability unless the process can be generalized or adapted effectively to other contexts. However, the paper does not thoroughly address how to establish and optimize the discovery pipeline across different scenarios, which could hinder its practical utility. More guidance on adapting the methodology to a variety of use cases would significantly enhance its value and impact.\n\nQUESTIONS:\n1. How well does the proposed LLM-driven discovery method generalize to other domains/tasks beyond preference optimization? Are there specific modifications needed to adapt this method to other fields?\n2. The authors mention that DiscoPOP blends logistic and exponential losses. Could you elaborate on the theoretical justification for this choice? How does this combination affect the convergence properties of the algorithm?\n3. Considering the non-convex nature of DiscoPOP, what strategies do you suggest to avoid local minima during optimization?\n\nLIMITATIONS:\nThe authors discussed the limitations of DiscoPOP.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-15"}