Towards Federated RLHF with Aggregated Client Preference for LLMs

## Abstract

Abstract Reinforcement learning with human feedback (RLHF) fine-tunes a pretrained large language model (LLM) using preference datasets, enabling the LLM to generate outputs that align with human preferences. Given the sensitive nature of these preference datasets held by various clients, there is a need to implement RLHF within a federated learning (FL) framework, where clients are reluctant to share their data due to privacy concerns. To address this, we introduce a feasible framework in which clients collaboratively train a binary selector with their preference datasets using our proposed FedBis . With a well-trained selector, we can further enhance the LLM that generates human-preferred completions. Meanwhile, we propose a novel algorithm, FedBiscuit , that trains multiple selectors by organizing clients into balanced and disjoint clusters based on their preferences. Compared to the FedBis , FedBiscuit demonstrates superior performance in simulating human preferences for pairwise completions. Our extensive experiments on federated human preference datasets – marking the first benchmark to address heterogeneous data partitioning among clients – demonstrate that FedBiscuit outperforms FedBis and even surpasses traditional centralized training.

## 1 Introduction

Large language models (LLMs) have demonstrated remarkable capacities in responding to a wide range of open-ended instructions as professionally as human beings. This achievement is attributed to reinforcement learning with human feedback (RLHF) Ziegler et al. (); Christiano et al. (); Ouyang et al. (), a method that aligns an LLM with human preferences. Specifically, it trains a reward model (a.k.a. preference model) with the help of a preference dataset, which includes the comparisons among various completions of given instructions. Then, it fine-tunes the LLM towards generating completions that closely match human preference,
evaluated by the reward model.

While empirical studies have validated the effectiveness of RLHF in enhancing LLM performance, RLHF faces a challenge regarding preference data collection. There are two approaches for constructing preference datasets, namely, human efforts Bai et al. (); Ganguli et al. (); Stiennon et al. () and ChatGPT generation Dubois et al. (). The former gathers the preference data from a team of labelers, who rank the completions of each instruction from best to worst. In contrast, the latter entails a set of instructions together with pairwise completions, with ChatGPT Achiam et al. () tasked with selecting the superior completion for each instruction. As LLMs are deployed to serve diverse clients, a preference gap may occur between clients and labelers/ChatGPT, impeding the LLM’s ability to generate responses that satisfy real clients’ tastes. Therefore, there is a demand for a preference dataset that accurately mirrors clients’ preferences in order to facilitate LLM performance.

One approach to meeting the demand is to collect client preference data and build a huge preference dataset, with which an LLM can be fine-tuned on a central entity (a.k.a. server). It is noticed that this approach has been applied to a recent open project named OASST Köpf et al. (). However, this approach may be infeasible because most clients refuse the disclosure of their preference data out of privacy concerns.

Figure: Figure 1: An outline of RLHF in federated learning.
Refer to caption: x1.png

To this end, we adopt FedAvg, a conventional federated learning (FL) algorithm Konečnỳ et al. (); McMahan et al. () that avoids the collection of clients’ raw data. Specifically, each client trains a reward model with their preference data, and the server aggregates the reward models into a global model. While the process seems effective, we observe the following two limitations during training:

- •
Excessive Computation Overhead: Conventionally, the reward model is designed to output a scalar value for a given prompt and completion Stiennon et al. (). Its optimization is based on reward differences between preferred and dispreferred completions, i.e., the preferred completions should earn greater rewards than the dispreferred ones. As a result, when the optimization involves a data sample in training the model, it should simultaneously retain two computation graphs in the forward and backward pass, leading to significant computation overhead and intensive GPU requirements.
- •
Degraded Performance: Preference data are heterogeneous among the clients in view that the preferences vary among the clients.
Consequently, each client trains a reward model towards a local minima, deviating from the global optima and resulting in a longer training time to converge when compared to the centralized training. Moreover, the method is likely to suffer from reward hacking, a phenomenon where the reward model heads to a poor performance after several training rounds Askell et al. (); Michaud et al. (); Tien et al. (); Skalse et al. ().

In this paper, we propose to address these two limitations and propose effective and computationally efficient methods for preference collection and subsequent fine-tuning. We start with a solution that addresses the first limitation.
The key idea is to train a binary selector, which chooses a superior response between two completions under a given instruction. Compared with preference ranking, the binary selector requires much less computation during training.
Casting binary selector training into a federated learning setting, we thus propose the
federated binary selector training (FedBis), as depicted in the first stage of Figure 1. Each client independently trains the selector with local preference dataset, and the server aggregates the selectors into a global one and broadcasts it to the clients. Afterwards, we utilize the binary selector to enhance the performance of LLM. Specifically, we assume the server holds a set of instructions, together with pairwise responses generated by an LLM. Then, we build a preference dataset with the help of the binary selector and boost the LLM by means of direct preference optimization (DPO) Rafailov et al. ().

To further address the performance deterioration due to preference heterogeneity and reward hacking, we propose a method named FedBis with cluster-wise aggregation (FedBiscuit).
This method ensembles multiple binary selectors, each trained by the clients possessing similar preferences. In light of privacy concerns, which prevent explicit sharing of clients’ data, the server intermittently collects client losses on all binary selectors. Subsequently, clients are organized into disjoint clusters,
and when comparing two completions, the one selected by the majority of binary selectors is deemed better. The proposed method has two main advantages. Firstly, clients with similar preferences jointly train a binary selector, moderating data heterogeneity and mitigating performance deterioration. Secondly, the method alleviates reward hacking by having numerous binary selectors jointly decide on optimal completions.

##### Contributions.

In this paper, our contributions are highlighted as follows:

- •
To the best of our knowledge, this is the first feasible framework to achieve RLHF in FL. In detail, the framework trains binary selector(s) with clients’ local datasets, distills the selector(s) toward an LLM, and boosts LLM performance in the meantime. Under this framework, we introduce two methods, i.e., FedBis and FedBiscuit.
- •
Previous works offer a number of human preference datasets, but none of them address the FL setting. This is the first work to discuss the possible data partition approaches to build a heterogeneous human preference dataset. To this end, we introduce a benchmark that includes several human preference datasets suitable for FL.
- •
We conduct extensive experiments to demonstrate the performance of the proposed FedBis and FedBiscuit. As expected, FedBiscuit demonstrates superior performance over FedBis and even surpasses traditional centralized training. Meanwhile, we present some insights from the empirical studies.

## 2 Related Work

##### LLM Fine-tuning in FL.

Recent studies have increasingly focused on fine-tuning large language models (LLMs) using federated datasets Sun et al. (); Ye et al. (); Zhang et al. (); Yi et al. (); Zhang et al. (). However, these approaches often suffer from high computation and communication costs due to the necessity of training and synchronizing the model with clients. To mitigate these issues, lightweight methods such as black-box fine-tuning Sun et al. (); Lin et al. () and offsite-tuning Wu et al. (); Kuang et al. () have emerged. Despite their advancements, these methods primarily focus on fine-tuning LLMs for specific downstream tasks, neglecting user preferences in the generated responses. To address this gap, our work aims to align LLMs with human preferences and introduces a feasible training framework in federated learning.

##### Reinforcement Learning with Human Feedback (RLHF).

RLHF typically involves supervised fine-tuning, reward modeling, and reward optimization, initially popularized by Christiano et al. (). Proximal Policy Optimization (PPO) Schulman et al. () is a common RLHF algorithm, yet it struggles with instability, inefficiency, and high resource demands Choshen et al. (); Engstrom et al. (). These challenges have led to the development of alternative methods, such as Direct Preference Optimization (DPO) Rafailov et al. () and others Dong et al. (); Zhao et al. (); Azar et al. (); Ethayarajh et al. (); Gulcehre et al. (), which offer more stable and efficient solutions. However, these methods typically operate within a centralized training framework, where the LLM owner retains control over the preference data. In contrast, our work seeks to expand data sources and incorporate real user preferences during the fine-tuning of the LLM.

## 3 FedBis : A Feasible Framework for Achieving RLHF in FL

The objective of RLHF is to align a pretrained language model with human preferences. RLHF comprises two phases: (i) preference modeling and (ii) reinforcement-learning fine-tuning. The first phase aims to develop a model that simulates human preferences to select the superior options from numerous pairwise completions. Subsequently, the second phase enhances the language model’s performance by creating a preference dataset, enabling the model to generate responses preferred by humans. In the following, We describe the proposed FedBis that achieves RLHF in FL in the first two subsections, followed by a brief discussion of its limitations that motivate the proposed FedBiscuit presented in Section 4.

### 3.1 Preference Modeling

#### 3.1.1 Problem Formulation.

In preference modeling, our objective is to train a binary selector using data from multiple clients. Consider an FL system with $M$ clients, coordinated by a central server. Denote the weight of client $m$ as $p_{m}$ such that $\sum_{m\in[M]}p_{m}=1$, and we aim to optimize the following objectives:

$$ $\min_{\phi\in\mathbb{R}^{d}}\quad F(\mathbf{\phi})\overset{\triangle}{=}\sum_{ m\in[M]}p_{m}F_{m}(\mathbf{\phi})$ (1) $$

where $F_{m}(\phi)$ is the expected loss on client $m$ given the binary selector $\phi$. Suppose client $m\in[M]$ holds a set of pairwise data with the size of $n_{m}$, i.e., $\hat{\mathcal{D}}_{m}=\{(x_{i},y_{i,w},y_{i,l})\}_{i\in[n_{m}]}$, where $x_{i}$ is the prompt, $y_{i,w}$ is the preferred completion out of the pair of $y_{i,w}$ and $y_{i,l}$.
We reorganize these data and build a preference dataset $\mathcal{D}_{m}$ to be $\{(x_{i},y_{i,w},y_{i,l},0),(x_{i},y_{i,l},y_{i,w},1)|(x_{i},y_{i,w},y_{i,l})
\in\hat{\mathcal{D}}_{m}\}$ for training, in which each contains the prompt, a pair of completions and preference selection. Apparently, this dataset eliminates the position effects, and we can train the selector as a classification task. Therefore, we utilize cross-entropy (CE) loss $\ell_{CE}$ to optimize the selector and formulate the expected loss as

$$ $\displaystyle F_{m}(\phi)=\mathbb{E}_{(x,y_{0},y_{1},i)\sim\mathcal{D}_{m}} \left[\ell_{CE}(i|\phi;x,y_{0},y_{1})\right].$ (2) $$

Next, we will discuss how to optimize the selector $\phi$ under the FL scenario.

#### 3.1.2 Algorithm Design

We consider a practical and efficient FL scenario where not all clients but only a sampled subsets of clients participate in each communication round Yang et al. ().
Before the commencement of FL training, we initialize the binary selector with a pretrained LLM such as LLaMA-2 Touvron et al. (), and set the hyperparameters.

An FL algorithm requires multiple communication rounds and consists of three phases in each round, i.e., model broadcast, local training, and global aggregation.
Following this paradigm, we design FedBis and optimize the selector $\phi$, i.e., in the communication round $r\in[R]$, as discussed as follows.

##### Step 1: Model Broadcast.

The server uniformly samples $A$ clients without replacement, denoted by $\mathcal{A}$. Let the selector be $\phi_{r}$ in the $r$-th communication round, and the server broadcasts it to the sampled clients.

##### Step 2: Local Training.

At this step, client $m\in\mathcal{A}$ optimizes the selector based on local preference data. First, the client initializes the local selector $\phi_{r,0}^{m}$ with the global selector $\phi_{r}$ received from the server. Subsequently, the client trains the selector for $K$ iterations, where the update rule between consecutive iterations follows:

$$ $\displaystyle\phi_{r,k+1}^{m}=\phi_{r,k}^{m}-\eta\nabla F_{m}(\phi_{r,k}^{m}), k\in[K]$ (3) $$

where the gradient $\nabla F_{m}(\phi_{r,k}^{m})$ is approximated using a data batch sampled from the local preference dataset $\mathcal{D}_{m}$and can incorporate optimizers such as AdamW Loshchilov and Hutter (). Finally, the client $m$ transmits the updated local selector $\phi_{r,K}^{m}$ back to the server.

##### Step 3: Global Aggregation.

After receiving the local selectors from the sampled clients $\mathcal{A}$, the server updates the global selector:

$$ $\displaystyle\phi_{r+1}=\frac{M}{A}\sum_{m\in\mathcal{A}}p_{m}\phi_{r,K}^{m}.$ (4) $$

This aggregation method, based on Li et al. () where the clients are uniformly sampled to train a global model, ensures consistency with Problem (1) in mathematical expectation.

After $R$ communication rounds of training, FedBis outputs a binary selector $\phi_{R}$ that reflects the overall preferences of all clients. The selector can then be used to enhance the performance of the LLM, as discussed in the next section.

### 3.2 Reinforcement-learning Fine-tuning

#### 3.2.1 Problem Formulation.

Traditionally, reinforcement-learning fine-tuning adopts PPO algorithm Schulman et al. () to enhance the performance of an LLM using a reward model that can rate a completion Stiennon et al. (); Ouyang et al. (); Dai et al. (), which does not fit the proposed framework with a binary selector.

One practical approach to aligning the LLM with clients’ preferences is to create a preference dataset with the help of the binary selector. Suppose the server holds a set of instructions $\hat{\mathcal{D}}$, and we can expand it to a preference dataset $\mathcal{D}_{gen}=\{(x,y_{0},y_{1},i)|x\in\hat{\mathcal{D}}\}$, where $y_{0}$ and $y_{1}$ are two completions generated by the LLM $\theta$, and $i\in\{0,1\}$ indicates the preferred completion as chosen by the binary selector $\phi$. With this generated dataset, we apply the Direct Preference Optimization (DPO) algorithm Rafailov et al. () to optimize the LLM consistent with clients’ preferences, which is formulated as

$$ $\displaystyle\min_{\theta}\mathbb{E}_{\begin{subarray}{c}(x,y_{0},y_{1},i)\sim {\mathcal{D}_{gen}}\end{subarray}}\mathcal{L}_{DPO}\left(\theta|x,y_{0},y_{1}, i\right)$ (5) $$

where the DPO loss is $\mathcal{L}_{DPO}\left(\theta|x,y_{0},y_{1},i\right)=-\log\sigma\left(\beta
\log\frac{\pi_{\theta}(y_{i}|x)}{\pi_{\theta_{0}}(y_{i}|x)}-\beta\log\frac{\pi
_{\theta}(y_{1-i}|x)}{\pi_{\theta_{0}}(y_{1-i}|x)}\right)$. Next we discuss the specifics of the preference data generation and LLM optimization.

#### 3.2.2 Algorithm Design

The reinforcement-learning fine-tuning takes place on the server and includes two phases: 1) a preference dataset is created with a pretrained LLM $\theta_{0}$ and a well-trained selector $\phi_{R}$ from FedBis. 2) LLM is optimized according to the objective defined in Equation (5) with the generated dataset.

##### Step 1: Preference Dataset Generation.

Suppose the server holds a set of instructions $\hat{\mathcal{D}}$. With the LLM $\theta_{0}$, we can generate multiple completions for an instruction $x\in\hat{\mathcal{D}}$, resulting in a set of $n$ completions $(y_{0},\dots,y_{n-1})\sim\pi_{\theta_{0}}(y|x)$. For each instruction, we can form a total of $\binom{n}{2}$ pairs of completions. We then use the binary selector $\phi_{R}$ to choose the optimal completion for each pair $(y_{j},y_{l})$ where $0\leq j<l\leq n-1$. The pair is labeled with $i=0$ if the first logit output is greater than the second, i.e., $\pi_{\phi_{R}}(0|x,y_{j},y_{l})>\pi_{\phi_{R}}(1|x,y_{j},y_{l})$, or $i=1$ otherwise. This process builds the preference dataset $\mathcal{D}_{gen}$.

##### Step 2: LLM Fine-tuning.

With the constructed preference dataset $\mathcal{D}_{gen}$, we evolve the LLM to align with clients’ preferences. Specifically, in the $t$-th training round, where $t\in\{0,1,\dots\}$, we sample a data batch $(x,y_{0},y_{1},i)$ from $\mathcal{D}_{gen}$, and update the LLM using the following rule:

$$ $\displaystyle\theta_{t+1}=\theta_{t}-\eta\nabla\mathcal{L}_{DPO}\left(\theta_{ t}|x,y_{0},y_{1},i\right),$ (6) $$

where $\eta$ is the learning rate. The gradient computation $\nabla\mathcal{L}_{DPO}$ is given by Rafailov et al. (). In a nutshell, we distill the binary selector’s preferences into the LLM, allowing it to function as a binary selector itself implicitly.

### 3.3 Discussion

We discuss the limitations of FedBis which motivate us to propose FedBiscuit.

##### Preference Heterogeneity.

A performance gap between FedBis and centralized training could arise from data heterogeneity among clients, a common issue in FL.
Different from centralized training that aggregates all the clients’ data and samples an i.i.d. batch in each training round, FedBis samples a subset of clients in each round, with each client independently optimizing the model based on their local data. This could result in a global aggregation that diverges from the global optimum Karimireddy et al. (); Wu et al. ().

##### Reward Hacking.

As demonstrated in experiments, FedBis’s performance improves first but may later decline with the increase of training rounds. This phenomenon, known as reward hacking, is discussed by Skalse et al. () as an inevitable issue in training a reward proxy model, which is used to enhance the performance of a policy model (e.g., LLM). However, we can mitigate this impact by delaying the inflection point, allowing the reward proxy model to continue improving performance for more training rounds and ultimately achieve a higher rating.

## 4 FedBiscuit : FedBis with Cluster-wise Aggregation

In this section, we aim to address the aforementioned limitations of FedBis.
To tackle reward hacking, Eisenstein et al. () and Coste et al. () introduce a promising approach that trains multiple reward models at the same time because aggregation over multiple reward model outputs can provide a more robust reward estimate. Furthermore, recognizing that some clients may share similar preferences, we employ clustered FL Sattler et al. (); Ghosh et al. (); Ma et al. () to group clients with similar preferences for joint model training. Notably, these two approaches complement each other, inspiring us to combine them into a novel algorithm FedBiscuit that simultaneously combats reward hacking and preference heterogeneity.

##### Problem Formulation.

In this work, we consider training multiple binary selectors of $U$. To ensure that all selectors are trained without bias towards a small specific group, we mandate that these selectors be trained using evenly disjoint clusters of clients. Additionally, a client’s preference should align more closely with those within the same cluster than with those in different clusters. To this end, we can formulate the following objective:

$$ $\displaystyle\min_{\phi_{[U]}\in\mathbb{R}^{U\times d}}F({\phi_{[U]}})\overset {\triangle}{=}\sum_{m\in[M]}p_{m}\left(\min_{u\in[U]}F_{m}({\phi_{u}})\right)$ $\displaystyle s.t.\quad\max\{|M_{u}|\}_{u\in[U]}-\min\{|M_{u}|\}_{u\in[U]}\leq 1$ (7) $$

where the function $F_{m}$ follows the same definition of Equation (2).
$\phi_{u}$ indicates the $u$-th binary selector, and $M_{u}$ means a set of clients using the $u$-th selector. By definition, $\cup_{u\in[U]}M_{u}=[M]$, and $\cap_{u\in[U]}M_{u}=\emptyset$.

Next we explore how the proposed FedBiscuit optimizes Equation (7).

### 4.1 Algorithm Design

Section 3.1 mentions that a client $m\in[M]$ holds a preference dataset $\mathcal{D}_{m}$. Before the model training, client $m$ splits her dataset into two disjoint sets, namely, a training set $\mathcal{D}_{m,train}$ and a validation set $\mathcal{D}_{m,val}$, where $|\mathcal{D}_{m,train}|>>|\mathcal{D}_{m,val}|$.

The proposed FedBiscuit consists of two phases: 1) We train each selector for a couple of rounds so that all $U$ selectors have fundamental capacities in selecting the preferred completion, and 2) we divide the clients into disjoint clusters of size $U$ and train each binary selector with a specific cluster.

##### Phase 1: Warm-up.

In the beginning, we initialize each binary selector $\phi_{u}(u\in[U])$ with an identical pretrained LLM. Subsequently, starting from $u=0$, we train a selector $\phi_{u}$ for $R_{pre}$ consecutive communication rounds following the steps of FedBis: In each communication round, the server samples a subset of client $\mathcal{A}$ and broadcasts the selector $\phi_{u}$ to them. Each client $m\in\mathcal{A}$ then locally trains the selector for $K$ iterations using the dataset $\mathcal{D}_{m,train}$. At the end of the communication round, the server aggregates and updates the selector $\phi_{u}$ via Equation (4). After completing the training of $\phi_{u}$, the server initiates the training of the next selector $\phi_{u+1}$ by repeating the above steps until all selectors are trained.

The selectors are trained with different data distributions because the clients participating in each training round are randomly selected. Consequently, all the selectors $\phi_{[U]}$ have distinct model parameters, leading to varied performance in terms of final logit output when given an instruction and a pair of completions.

##### Phase 2: Clustered FL Training.

After the first phase, we obtain $U$ different selectors, denoted as $\{\phi_{u,0}\}_{u\in[U]}$. Unlike FedBis, this phase includes an additional step called client grouping, which partitions the clients into multiple disjoint clusters based on their preferences. In each communication round $r\in[R]$, the proposed FedBiscuit optimizes all the selectors $\phi_{[U]}$ using the following four steps:

Step 2.1: Client Grouping. This step is executed every $\tau$ communication rounds, i.e., when $r$ can be divided by $\tau$, or $\tau|r$. During this step, the server broadcasts all selectors $\phi_{[U],r}$ to all clients $[M]$. Then, a client $m$ calculates the averaged loss for each selector $\phi_{u,r}$ using local validation set via $\frac{1}{|\mathcal{D}_{m,val}|}\sum_{(x,y_{0},y_{1},i)\sim\mathcal{D}_{m,val}}
\left[\ell_{CE}(i|\phi_{u,r};x,y_{0},y_{1})\right]$. The server thereby collects all these losses and adopts a greedy clustering approach Sattler et al. (); Ma et al. () to assign each client to the selector where they achieve the minimum loss. However, an obvious deficiency is an imbalance where some selectors are chosen by many clients and others by few. It is noted that the selectors trained with more clients achieve remarkable performance, while some may be overfitted to a specific group of clients. Therefore, the greedy clustering approach negatively impacts the overall performance when building a global preference dataset. To tackle the limitation, we propose to balance the clusters using the following steps repeatedly until the clients are evenly distributed:

- •
Choose the cluster selected by the most clients.
- •
If the cluster can accommodate $n$ clients, cap the cluster at $n$ clients and reassign the rest to other clusters where they achieve suboptimal loss.

Finally, we obtain balanced and disjoint clusters. Let a client $m$ train with the $U_{m}$-th selector $\phi_{U_{m}}$ for the next $\tau$ rounds. After client grouping step, the proposed method proceeds to the following three steps as outlined in FedBis.

Step 2.2: Model Broadcast. Similar to FedBis, the server samples $A$ clients from all clients $[M]$, denoted by $\mathcal{A}$. For each selected client $m\in\mathcal{A}$, the server transmits the selector $\phi_{U_{m},r}$. This process can be characterized by defining $\mathcal{A}_{u}$ as the group of clients chosen to train the selector $\phi_{u}$. This ensures that $\cup_{u\in[U]}\mathcal{A}_{u}=\mathcal{A}$ and $\cap_{u\in[U]}\mathcal{A}_{u}=\emptyset$.

Step 2.3: Local Training. The client $m\in\mathcal{A}$ receives a binary selector $\phi_{U_{m},r}$ from the server and trains the selector for $K$ iterations following the update rule of Equation (3). Finally, let the updated local selector be $\phi_{U_{m},r,K}^{m}$, and the client pushes it to the server.

Step 2.4: Global Aggregation. The server collects updated selectors from all participants $\mathcal{A}$. Since there are several binary selectors, the server updates each one with a designated group of clients intended to train on that specific selector. For instance, the aggregation rule for the selector $u\in[U]$ follows

$$ $\displaystyle\phi_{u,r+1}=\left(1-\sum_{m\in\mathcal{A}_{u}}p_{m}\right)\phi_{ u,r}+\sum_{m\in\mathcal{A}_{u}}p_{m}\phi_{u,r,K}^{m}$ (8) $$

It is noted that performance degradation occurs when a model is trained by clients with time-varying sizes in FedAvg Gu et al. (); Wang and Ji (). In other words, Equation (4) is no longer suitable for multi-selector aggregation due to the fluctuation in the number of clients training a selector in each communication round. Therefore, FedBiscuit adopts a new aggregation rule as formulated in Equation (8).

FedBiscuit finally produces a set of well-trained selectors $\phi_{[U],R}$ and he subsequent objective is to enhance LLM performance with the help of these selectors, as explored below.

##### Reinforcement-learning Fine-tuning with Multiple Selectors.

We can leverage the methodology mentioned in Section 3.2, and one of the key steps involves constructing a preference dataset incorporating multiple selectors. For this, we employ a strategy of majority voting. Given an instruction $x\in\hat{\mathcal{D}}$ and a pair of generated completions $(y_{0},y_{1})$, we assume a selector $u\in[U]$ prefers $y_{i_{u}}$, where $i_{u}\in\{0,1\}$. Therefore, the pair is assigned a label $i=\arg\max\{i_{u}\}_{u\in[U]}$, meaning that the completion $y_{i}$ is favored by the most clients.

### 4.2 Discussion: Integration with LoRA

As all binary selectors are LLM, training them may consume significant communication and computation overheads. Besides, multiple LLMs lead to considerable storage burdens shouldered by the server. To reduce the costs, we adopt a parameter-efficient fine-tuning approach LoRA Hu et al. (), where all binary selectors share the same base model while using different adapters.

In comparison with FedBis, FedBiscuit requires extra costs, i.e., $O(MU\lfloor R/\tau\rfloor\cdot C)$, where $C$ is the communication cost of a selector. This is because FedBiscuit involves client grouping periodically, unilaterally transferring all selectors from the server to the clients. Despite the extra costs, extensive experiments demonstrate non-trivial improvement by comparing FedBiscuit with FedBis.

## 5 Federated Human Preference Benchmark

This section mainly focuses on how we prepare federated human preference datasets, while the next section introduces the experimental setup and analyzes numerical results. Specifically, we cover two of the most common NLP tasks, i.e., summarization and question-answering. All two datasets are partitioned based on the public datasets, and the following subsections will include the details. We will release these datasets on HuggingFace soon.

##### Summarization.

Stiennon et al. () introduces a summarization dataset that consists of Reddit posts with human-written tl;dr Völske et al. (). This dataset consists of two parts, one is a pretrained dataset, while the other is a dataset with human preference. As suggested by Ouyang et al. (), we ensure a post does not appear in both datasets. We assume the pretrained dataset is stored on the server side, and 60% of data are served for model pertaining such that the model can perform well on summarization. The remaining 40% are used for the RLHF process to improve the LLM performance and generate human-preferred content. Since the human-preference dataset contains the worker ID, we partition the dataset based on the worker ID so that the dataset can be partitioned into 53 workers.

##### Question-Answering (QA).

We reconstruct the public dataset SHP, which comprises numerous questions from Reddit posts and their corresponding user answers Ethayarajh et al. (). The preference indicator is based on the number of likes an answer receives. Given that the dataset spans 18 domains, we partition the dataset using a Dirichlet distribution with a parameter of 0.3, ensuring that no questions overlap between clients. In our experiment, we prepare 300 clients, and Figure 2 visualizes the data distribution on the selected clients. For the RLHF process, we use a set of 2.6K Reddit questions.

Figure: Figure 2: Data distribution across different question domains on the selected clients.
Refer to caption: x2.png

## 6 Experiments

### 6.1 Experimental Setup

##### Model and computation environment.

We initialize the binary selector(s) using the pretrained LLaMA-2-7B Touvron et al. (), configuring the final layer to produce binary outputs "A" and "B" only. The LLM chosen for content generation depends on the tasks: (i) For the summarization task, we start with LLaMA-2-7B and fine-tune it using a pretrained dataset; (ii) For the QA task, we initialize the LLM with Alpaca-7B Taori et al. (). To reduce computation efforts, we employ LoRA to fine-tune the models. Our implementation, built upon FederatedScope Xie et al. (); Kuang et al. (), will soon be available on GitHub. The experiments are conducted on machines equipped with two Nvidia A100 GPU cards, Intel Xeon Platinum 8369B CPUs, and 256GB RAM.

##### Evaluation.

We evaluate two models produced by our proposed FedBis and FedBiscuit: a binary selector and an LLM. We employ different strategies to assess each model:

- •
Binary selector: The evaluation includes two metrics: agreement and best-of-$n$. Agreement measures the hit rate of a selector against a preference dataset annotated by humans or ChatGPT. Additionally, we use the best-of-$n$ approach by selecting the best completion from $n$ generated by a task-specific LLM. We then evaluate the average rating for the selector’s choices using Auto-J Li et al. ().
- •
LLM: After reinforcement-learning fine-tuning, the LLM is evaluated on its ability to generate human-preferred content. This means we can assess the quality of the generated texts. For example, given an instruction set, the LLM produces one completion per instruction, and Auto-J evaluates the average rating of these completions. Furthermore, we compare the generated completions with a reference set of responses, annotated by humans or ChatGPT, and calculate a win rate based on how often the generated response is superior to the reference one.

Due to the space limit, the hyperparameter settings are presented in Appendix A. Moreover, Appendix B provides real cases to demonstrate the performance of the proposed FedBis and FedBiscuit. In particular, Appendix B.1 discusses the results under the QA task.

### 6.2 Numerical Results on Summarization

**Table 1: Performce under summarization task. All values here indicate their best performance within 500 communication rounds of training.**
|  | Selector |  | LLM |  |  |
| --- | --- | --- | --- | --- | --- |
|  | Agreement | Best-of-$n$ |  | Rating | Win Rate |
| SFT | - | - |  | 5.028 | 29.71% |
| Centralized | 73.10% | 5.302 |  | 5.688 | 78.89% |
| FedBis | 70.44% | 5.274 |  | 5.661 | 71.35% |
| FedBiscuit | 70.52% | 5.305 |  | 5.703 | 80.65% |

In this section, the evaluation data originates from the TL;DR dataset, as mentioned in Section 5. The dataset comprises two disjoint parts: one ranked by a group of labelers for model-generated responses, and the other written by users to summarize the key content of a post. We use the former to compute the consistency between the selector and the human annotator. For the latter, we apply various metrics, including best-of-$n$, rating, and win rate. The results are presented in Table 1 and Figure 3.

The table shows that conventional centralized training outperforms the proposed FedBiscuit in terms of agreement. This is because the agreement evaluation data have a similar distribution to the training dataset, as their outputs are generated from the same language models and labeled by the same group of labelers Stiennon et al. (). Consequently, centralized training performs better than the proposed FedBis and FedBiscuit, which are affected by data heterogeneity.

However, when evaluating the selectors with datasets generated by a supervised fine-tuning model, the proposed FedBiscuit slightly outperforms centralized training. These results suggest that a centrally trained selector performs poorly in terms of generalization and is prone to overfitting to a specific dataset distribution. In contrast, comparing FedBiscuit with FedBis, we find that FedBiscuit mitigates data heterogeneity and produces a more robust selection of completion pairs.

Figure: Figure 3: Auto-J rating of best-of-$n$ against communication rounds under summarization tasks.
Refer to caption: x3.png

Figure 3 illustrates the performance trend across communication rounds. As discussed in Section 3.3, training a binary selector can lead to reward hacking. For both centralized training and FedBis, which train a single selector, we observe an inflection point where the selector’s performance begins to decline. However, this inflection point has not yet appeared in FedBiscuit, allowing it to continuously improve and eventually surpass the best performance of centralized training. It is important to note that the warmup rounds are included in the communication rounds, which explains FedBiscuit’s initial poor performance.

## 7 Conclusion

In this work, we explore a feasible framework to achieve RLHF in FL. Specifically, we train a binary selector across different clients using their local preference datasets, and then use the well-trained selector to align an LLM with human preferences. We propose two approaches to enable selector training: FedBis and FedBiscuit. FedBis provides a framework to train a single selector, while FedBiscuit ensembles multiple selectors to more robustly simulate human preferences. With the proposed federated human preference datasets, we conduct empirical studies to validate our statements and demonstrate the superiority of FedBiscuit.

## Ethics Statement

This paper investigates clients’ preferences using a publicly available dataset, ensuring that all data sources are appropriately cited to maintain academic integrity and transparency. By leveraging this public dataset, we avoid using private or sensitive client data, thus upholding ethical standards in data usage and research practices. Furthermore, this work prioritizes the protection of clients’ privacy and strictly avoids any disclosure of local data. When clients utilize their own data to fine-tune the model, robust privacy measures are in place to ensure that no other clients can access or infer any information related to their data. This approach not only safeguards individual privacy but also fosters trust and security in the application of the model.

## Limitations

One notable limitation of our work lies in the construction of the preference dataset, which relies solely on publicly available data rather than gathering information directly from real clients. By doing so, we miss out on the nuances and intricacies of individual preferences that can only be captured through firsthand data collection. As a result, our dataset may lack the depth and breadth necessary to fully comprehend the true heterogeneity of preferences among clients. Without access to authentic client data, we may inadvertently overlook important variations in preferences, potentially limiting the applicability and robustness of our findings.

Another limitation pertains to the use of a task-specific dataset rather than a more generalized one encompassing a broader spectrum of tasks. While task-specific datasets offer advantages such as focused analysis and tailored insights, they may also restrict the scope of our research and hinder its generalizability. By incorporating a more diverse range of tasks into our dataset, we could gain a more comprehensive understanding of clients’ preferences across various domains, thereby enhancing the versatility and validity of our findings.

Additionally, our work employs a binary selector that implicitly assumes one response is superior to another, overlooking scenarios where responses may exhibit similar levels of quality. This oversimplified approach fails to leverage valuable data that could provide valuable insights into subtle differences and nuances in preferences. By adopting a more nuanced and inclusive framework that acknowledges and incorporates variations in response quality, we could extract richer insights and make more informed decisions regarding client preferences. Addressing these limitations could bolster the robustness and validity of our research, ultimately enhancing its relevance and impact in real-world applications.

## Appendix A More Implementation Details

In this section, we include various settings, such as the prompt and the hyperparameters.

### A.1 Hyperparameter Settings

In our work, we fine-tune all models using LoRA, which is consistently set to rank 8, $\alpha=16$, and the dropout rate 0.0. For the generation, we apply with these parameters:

- •
If it is required to generate multiple completions, then we set the temperature to 1.0.
- •
If it is required to generate a single completion, then we adopt greedy search by setting the temperature to 0.0.

In the following part, we show the hyperparameter setting for different tasks:

**Table 2: Hyperparameter Settings for the Summarization Task**
|  | SFT | Selector Training | RLFT |
| --- | --- | --- | --- |
| Participation Rate | - | 5/53 | - |
| Local Iterations | 30 | 30 | 30 |
| Batch Size | 32 | 16 | 32 |
| Rounds | 1000 | 500 | 500 |
| Optimizer | AdamW | AdamW | RMSprop |
| Hyperparameters | (0.9, 0.95) | (0.9, 0.95) | – |
| Learning rate | $1e-4$ | $1e-5$ | $1e-6$ |

**Table 3: Hyperparameter Settings for the QA Task**
|  | Selector Training | RLFT |
| --- | --- | --- |
| Participation Rate | 10/300 | - |
| Local Iterations | 10 | 10 |
| Batch Size | 16 | 16 |
| Rounds | 200 | 200 |
| Optimizer | AdamW | RMSprop |
| Hyperparameters | (0.9, 0.95) | – |
| Learning rate | $1e-5$ | $1e-6$ |

##### Special Setting for FedBiscuit

For the above two tasks, we ensemble three binary selectors (i.e., LoRAs). In the warmup round, we train the selector for 50 rounds under an FL framework. FedBiscuit performs regrouping every 50 rounds in the summarization task, while regrouping every 100 rounds in the QA task.

### A.2 Instruction Tuning Prompt

In this section, we highlight the prompts used to fine-tune the summarization tasks and the QA task:

##### Summarization.

For pertaining (SFT) and the later reinforcement-learning fine-tuning (RLFT), it follows the prompt below

| Below is a forum post. Write a precise and concise summary that includes the most important points of the post.<br>### SUBREDDIT: r/{subreddit}<br>### TITLE: {title}<br>### POST: {post}<br>### TL;DR: |
| --- |

For comparison:

| Below is a forum post followed by two summaries. Pick a more precise and concise one that summarizes the most important points in the given forum post, without including unimportant or irrelevant details. State your choice with a single capital letter, i.e., Äïf SUMMARY A is better, B̈ïf SUMMARY B is better.<br>### SUBREDDIT: r/{subreddit}<br>### TITLE: {title}<br>### POST: {post}<br>### SUMMARY A: {output_A}<br>### SUMMARY B: {output_B}<br>### YOUR CHOICE: |
| --- |

##### QA.

As the QA utilizes a pretrained model named Alpaca-7B, we follow its pretrained format

| Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.<br>### Instruction:<br>{instruction}<br>### Input:<br>{input}<br>### Response: |
| --- |

For comparison between the two responses:

| Below is a query followed by two responses. Pick a helpful response that is precise, concise, and casual. State your choice with a single capital letter, i.e., Äïf RESPONSE A is better, B̈ïf RESPONSE B is better.<br>### QUERY: {instruction}<br>### RESPONSE A: {output_A}<br>### RESPONSE B: {output_B}<br>### YOUR CHOICE: |
| --- |

## Appendix B More Numerical Results and Analysis

### B.1 Numerical Results on QA

In this section, the test dataset comes from AlpacaFarm Dubois et al. (); Li et al. (). The results are as follows:

**Table 4: Performce under QA.**
|  | 2-completion |  | 4-completion |
| --- | --- | --- | --- |
|  | Rating |  | Rating |
| Alpaca-7B | 3.752 |  | - |
| FedBis | 4.140 |  | 4.113 |
| FedBiscuit | 4.094 |  | 3.830 |

As presented in Section 4, the LLM owner will generate a set of responses to a given instruction before building a preference dataset. Therefore, the column "2-completion" means the owner prepares 2 completions for each instruction, while "4-completion" means 4 completions for each instruction and forms 6 pairs. The row "Alpaca-7B" acts as a baseline to help us understand the performance of the proposed FedBiscuit and FedBis. All the rating comes from Auto-J Li et al. (), which would be different from the ratings reported by Li et al. () because it evaluates with GPT-4 Achiam et al. ().

The table above may lead to conclusions different from those drawn from the summarization task. First, FedBis achieves better performance than FedBiscuit. This is within our expectations. First, these selectors are trained for a total of 200 rounds. As presented in Figure 3, FedBiscuit surpasses FedBis after 300 communication rounds. This is because the selectors of FedBiscuit are trained for 100 rounds only, while the selector of FedBis has been fully trained for 200 rounds. When the inflection point appears in FedBis, we can hypothesize that the dominance of FedBiscuit still exists.

Another comparison arises between different numbers of generations to a given prompt. From the table, we notice that "2-completion" can achieve better performance than "4-completion," meaning that the performance may not be relevant to the size of the RLFT training set. Instead, it may rely on the quality of the training data. As we can see, Alpaca-7B hardly generates high-quality data, leading to limited improvement with training with these generated data. In other words, if we generate more low-quality completions, the improvement of the model would be more limited. At the same time, we can hypothesize that if the generated data are of high quality, "4-completion" may outperform "2-completion" in terms of the final rating.

### B.2 Examples on the Final RLHF Results

In this section, we prepare two examples to illustrate the performance of our proposed FedBis and FedBiscuit and compare them with other baselines. Refer to Table 5 and Table 6 for the demonstration of the examples.

**Table 5: An example for summarization task. Caution: The example data that may be offensive or harmful.**
| Subreddit: r/relationships<br>Title:<br>Me [25F] with my SO [27 M] of 3.5 years, I went through his texts and can’t stop thinking about something I saw.<br>Post:<br>I admit that going through his text messages was wrong and I do feel incredibly guilty about it now but the bigger issue for me is that I found something that I can’t stop thinking about. He was talking to his good female friend and I saw a text that said "am I being an idiot for leaving [my name]"? . I stopped reading after that because I started having a panic attack. The idea of breaking up was not even on my radar and I thought he was more than happy. Again, I know I shouldn’t have looked but whats done is done and now I can’t stop worrying about when it’s going to happen. And now i’m being clingy just because of my worry which i’m sure doesn’t help. I love him and don’t want to lose him. |
| --- |
| Human Summary:<br>I saw a text from my SO to his friend about leaving me, can’t stop freaking out. Need serious advice. |
| SFT:<br>I went through my SO’s texts and found something I wasn’t supposed to. Now I’m being clingy and I don’t want to lose him. |
| Centralized:<br>went through my boyfriends texts and found something that i’m now worrying about when/if he’s going to break up with me. I love him and don’t want to lose him. Help. |
| FedBis:<br>went through SO’s texts and found a text that said "am I being an idot for leaving [my name]"? and now I’m worried he’s going to break up with me and can’t stop thinking about it. |
| FedBiscuit:<br>went through SO’s texts, found something that i’m now worrying about when the inevitable breakup is going to happen. Now being clingy and can’t stop thinking about it. Help! |
|  |

**Table 6: An example for QA task. Caution: The example data that may be offensive or harmful.**
| List the layers of the TCP/IP model and for each layer identify one protocol. |
| --- |
| Alpaca-7B:<br>The TCP/IP model consists of four layers: the application layer, transport layer, internet layer and network access layer.<br>Application Layer: HTTP<br>Transport Layer: TCP<br>Internet Layer: IP<br>Network Access Layer: Ethernet |
| FedBis:<br>The TCP/IP model has four layers: the application layer, transport layer, internet layer and network access layer. At the application layer, the protocol is TCP. At the transport layer, the protocol is UDP. At the internet layer, the protocol is IP. At the network access layer, the protocol is Ethernet.<br>1. Application layer: TCP<br>2. Transport layer: UDP<br>3. Internet layer: IP<br>4. Network access layer: Ethernet |
| FedBiscuit:<br>The TCP/IP model has four layers: the application layer, transport layer, internet layer and network access layer. At the application layer, the HTTP protocol is used. The transport layer uses the TCP protocol. At the internet layer, the IP protocol is used. Finally, the network access layer uses the Ethernet protocol. |
|  |

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: It may not be easy to add more experimental results in the rebuttal period. But can the proposed method also enhance RLHF ability of LLM in other NLP tasks like few-shot learning, synthetic, code completion, multi-needle retrieval?
soundness: 2
strengths: (1)	This paper provides a novel federated learning-based reinforcement learning method to enhance the output ability of LLM. To the best of my knowledge, this is the first time to employ federated learning technique to enable diverse user collection for RLHF.

(2)	The organization of this paper is clear and easy to follow. In particular, Figure 2 clearly depicts the outline of the proposed FedBis model.

(3)	The algorithm design in Section 5.1 is practical and new to me. Besides, the key component of the algorithm (i.e. training a binary selector and aggregating different selectors to the LLM server) effectively incorporates federated learning idea into the design of RLHF model.

(4)	The experimental results on summarization and question-answering dataset validate the advantages of the proposed algorithm over existing methods.
summary: Reinforcement learning with human feedback (RLHF) is a good way to fine-tune a pretrained large language model (LLM) to generate content aligned with human preferences. This paper proposes to use federated learning technique to aggregate different model information from users to enhance RLHF ability of LLM. Concretely, the proposed federated RLHF methods encode each client’s preferences into binary selectors and aggregate them to capture common preferences. This method overcomes key challenges like preference heterogeneity and reward hacking to enhance LLM output quality. Experiments on two LLM benchmarks demonstrate the effectiveness of the proposed federated RLHF algorithm.
weaknesses: (1)	The experimental results in Section 7 are not extensive enough. This paper conducts experiments on two NLP tasks, summarization and question-answering, and more experiments on other tasks should be complemented, like few-shot learning, synthetic, code completion, multi-needle retrieval.

(2)	I admire the proposed FL-based reinforcement learning method, but it will be more readable and more concise to summarize the contents in Section 5.1 Algorithm Design into a pseudocode (i.e. shown in an Algorithm).

(3)	Lines 70-77 in Introduction is about the limitation of preference heterogeneity and reward hacking, and such limitation appears (in detail) once again in lines 224-237 of methodology. It suffices to mention such limitation once in one paper, or at least, not to emphasize it twice (e.g. not use bold to highlight it).

(4)	Section 6 is about the details of the experimental datasets, and will be better to defer it to Section 7 Experiments.

(5)	It will be better to use \begin{small} or other writing skill, to make Eq.(2) and Eq.(4) shown in one line.

(6)	Lines 237,294, 471, isolated word

(7)	Line 268, fix “. $\phi _{u}$”

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 4
questions: What are the unique challenges posed by employing federated learning to RLHF?
How RLHF impact the challenges and solution design presented in the paper?
What is the motivation behind the binary selector? what are the alternatives and why binary selectior, in particular, is chosen to be part of the solution?
soundness: 3
strengths: - The paper deals with an important research problem.
- The paper is generally well orgnaised and presente, and easy to follow.
- The authors proposed a sound solution to the research problem, showing advantages over baselines.
summary: The paper deals with privacy preservation through applying federated learning to employing user preferneces to fine-tune a common LLM. The synergy of reinforcement learning, large language model, and federated learning appears apealing to me. The paper presents nicely with an intuitive comparison between standard and fedrated RLHF, making the problem easy to follow.
weaknesses: - The challenged identifiied on Page 2 seems univeral and apply to many federated learning scenarios, not specified to this paper's research context. Therefore, although the overall problem setting seems to be new, the key research problem to tackle remains conventional.
- To deal with excessive comptuation overhad and preference heterogeneity seem to be a common issue that has been addressed by various previous efforts. The clustering approach to addressing the key issue does not appear novel to me.
- The cons of appplying the federated learning approach might be discussed for readers to better understand the trade-off.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Please see weaknesses.
soundness: 3
strengths: 1、Generally, this paper is well-written with clear explanations of the methodologies and results. 

2、The proposed FedBis and FedBiscui demonstrate good performance on several benchmarks, suggesting good-quality research and implementation.

3、This paper addresses the heterogeneity issue, an important issue in all fields of federated learning related research.
summary: This paper leverages federated learning into reinforcement learning with human feedback (RLHF) and proposes two federated-based RLHP methdos (FedBis and FedBiscui) to fine-tune large language models using user preference while preserving data privacy. The methods employ binary selectors to aggregate client preferences without requiring direct data sharing. FedBiscuit extends the functionality of FedBis by addressing preference heterogeneity and mitigating reward hacking. Experiments demonstrate that FedBis and FedBiscui perform better on Summarization task and QA task.
weaknesses: 1、It would be better to include experiments that explore the sensitivity of the hyperparameters, particularly the number of clusters $U$, which is a crucial or even central parameter in the FedBiscuit method. However, the current results only present cases for $U=3$ and $U=5$, providing limited insights from these two configurations.

2、The authors should further explain why FedBiscuit with $U=3$ performs better in some cases while $U=5$ yields superior results in others. Since FedBiscuit addresses the heterogeneity issue, and as noted in existing federated learning literature, particularly in cluster-based federated learning approaches, the number of clusters is a key factor. Understanding the impact of different cluster sizes on the method’s effectiveness would be valuable.

3、The additional complexity introduced by clustering and the use of multiple selectors in FedBiscuit may still pose scalability challenges, particularly in real-world applications with thousands of clients. It would be helpful to provide more analysis on the scalability of the approach, especially under varying numbers of clients and communication costs. This would shed light on the method’s feasibility for large-scale deployment.

---

confidence: 2
contribution: 3
initial_rating: 6
presentation: 3
questions: -Is there any data available on the training time or memory footprint of the entire training process?

-Given that LoRA configuration also has an impact on performance, can the authors provide the detailed information about the LoRA configuration used in their experiments?
soundness: 3
strengths: -The workload is impressive, every part is introduced in detail.

-The idea of training binary selectors to encode client’s preferences is novel.

-The two proposed methods are reasonable and both have many details in addressing the issues faced by traditional method.
summary: This paper proposes a federated RLHF method specially designed for large-scale preference collection, which encodes each client’s preferences into binary selectors and aggregates them to capture common preferences. An enhanced method is also introduced, which overcomes the challenges of preference heterogeneity and reward hacking by grouping similar clients and leveraging multiple binary selectors to improve LLM output quality. The authors also established a novel federated RLHF benchmark for evaluation. Experimental results show the superiority of the proposed model.
weaknesses: -Computation overhead. This method involves additional training of binary selectors, which are pre-trained LLMs. Although the authors apply LoRA to reduce the computation cost, the time and computation overhead of fine-tuning LLM selectors are still not negligible, which limits its application scenario.

-The experiments need supplements: In the section of performance analysis on different binary selectors, the experiments applied three base model with both different model structure and parameter size. To make the results more convincing, the effect of model type and model size should be explored separately.

Meta-review: Reinforcement learning with human feedback (RLHF) is an effective method for fine-tuning pretrained large language models (LLMs) to align their outputs with human preferences. This paper introduces a novel approach that leverages federated learning to aggregate diverse model information from users, enhancing the RLHF capabilities of LLMs. Specifically, the proposed federated RLHF framework encodes each client’s preferences into binary selectors, which are aggregated to identify and capture shared preferences across users. This approach addresses critical challenges such as preference heterogeneity and reward hacking, significantly improving the quality of LLM outputs. Experimental results on two LLM benchmarks validate the effectiveness of the proposed federated RLHF algorithm.

+ The paper introduced an interesting model for federated learning
+ The paper is well written
- The computational cost of the model can be further analyzed
- The experiments can be further improved by introducing more baselines

Decision: Accept (Poster)