Language Models Learn to Mislead Humans via RLHF

## Abstract

Abstract Language models (LMs) can produce errors that are hard to detect for humans, especially when the task is complex.
RLHF, the most popular post-training method, may exacerbate this problem: to achieve higher rewards, LMs might get better at convincing humans that they are right even when they are wrong.
We study this phenomenon under a standard RLHF pipeline, calling it “ U-Sophistry ” since it is U nintended by model developers.
Specifically, we ask time-constrained (e.g., 3-10 minutes) human subjects to evaluate the correctness of model outputs and calculate humans’ accuracy against gold labels.
On a question-answering task (QuALITY) and programming task (APPS),
RLHF makes LMs better at convincing our subjects but not at completing the task correctly.
RLHF also makes the model harder to evaluate: our subjects’ false positive rate increases by 24.1% on QuALITY and 18.3% on APPS.
Finally, we show that probing, a state-of-the-art approach for detecting I ntended Sophistry (e.g. backdoored LMs), does not generalize to U-Sophistry .
Our results highlight an important failure mode of RLHF and call for more research in assisting humans to align them.

## 1 Introduction

Language models (LMs) are used for more complex tasks as they become more capable.
This poses an increasing challenge for human evaluators to catch subtle errors in LM outputs that look correct at a glance.
A gap emerges between what is correct and what looks correct to humans.

This gap may cause reward hacking in RLHF (Skalse et al., ): to achieve higher rewards, LMs could learn to convince humans that they are correct even when they are wrong.
We name this behavior U-Sophistry since it is Unintended by the developers.
U-Sophistry is a consequence of Goodhardt’s Law: human approvals provide less accurate evaluations when they become the optimization target.

U-Sophistry poses significant risks when we use LMs for complex and critical tasks. For instance, RLHF might make AI better at persuading humans to accept inaccurate scientific findings or biased policies on high-stakes issues (Hendrycks et al., ).
This is ironic: while RLHF is supposed to control AI, it might deceive humans into believing that they are in control (Christiano, ).

While likely in theory (Skalse et al., ), U-Sophistry is yet to be empirically validated.
Many prior works study I-Sophistry: while they aim to study unintended misleading AI behaviors, they induce these behaviors Intentionally with non-standard engineering practices and hope their conclusions can generalize to U-Sophistry.
For example, Sharma et al. () explicitly prompts LMs to deceive human subjects, Hubinger et al. () fine-tunes LMs on malicious behaviors, and Denison et al. () uses brittle rewards designed to be hacked.(^1^11We discuss related works in Section 2.1 and Section 5.)
In contrast, we study U-Sophistry that naturally emerges from standard, innocuous practices: we need to know whether U-Sophistry matters in practice, how LMs can mislead humans, and what mitigations are effective.

We empirically investigate U-Sophistry in two tasks: long-passage question-answering and algorithmic programming.
We ask time-constrained (e.g. 3-10 minutes) human subjects to evaluate the correctness of LM’s outputs.
We then measure U-Sophistry by calculating human evaluation accuracy against gold labels before and after RLHF.

With 150 hours of human study, we find that U-Sophistry emerges even under widely-accepted reward signals, e.g. optimizing against a reward model learned from the ChatbotArena human preference data (Chiang et al., ).
We find that after RLHF, the LM does not get better at the task, but it misleads our subjects to approve its incorrect answers more often.
Our subjects become worse at evaluating LM’s outputs: their false positive rate increases by 24% on question-answering (QuALITY) (Pang et al., ) and 18% on programming (APPS) (Hendrycks et al., ).
Our subjects are also misled to confidently mislabel incorrect outputs as correct.

We qualitatively analyze how LMs mislead our subjects after RLHF by surveying their feedback.
On question-answering, LMs learn to defend incorrect answers by cherry-picking or fabricating supporting evidence, making consistent but untruthful arguments,
and providing arguments that contain subtle causal fallacies.
On the programming task, LMs learn to generate partially incorrect programs that still pass all evaluator-designed unit tests, produce less readable programs, and make fewer common errors that humans typically check for.

Finally, we evaluate prior mitigation methods to detect U-Sophistry.
We experiment with the probing method from MacDiarmid et al. (), which achieves a near-perfect accuracy (99.3% AuROC) at detecting I-Sophistry from Sleeper Agents (Hubinger et al., ), an LM fine-tuned to generate flawed programs when certain backdoor trigger appears.
This probing method fails for detecting U-Sophistry, performing no better than chance.
Therefore, I-Sophistry detection is not a good benchmark for methods meant for detecting U-Sophistry.
As AI capabilities rapidly increase, our results call for more research in assisting human evaluators against U-Sophistry.

## 2 U-Sophistry Emerges as an Unintended Consequence of RLHF

We first provide background on RLHF and introduce three different rewards: $R^{*}$ (correctness), $R^{\text{human}}$ (human ratings), and $R^{\text{train}}$ (reward in RLHF training).
We then hypothesize how these reward functions interact with each other during RLHF and increase U-Sophistry as a result.

RLHF Background. RLHF (Christiano et al., ) is a popular method for aligning LMs. At a high level, it collects human evaluations on a dataset of outputs, trains a reward model to imitate human evaluations, and then optimizes a policy against the reward model.
We call the LM before RLHF $\pi_{\text{init}}$ and the LM after RLHF $\pi_{\text{rlhf}}$. RLHF involves three different rewards: $R^{*}$, $R^{\text{human}}$, and $R^{\text{train}}$, each of which
is a function that maps an input-output pair to a scalar value.

- •
Oracle Reward $R^{*}$ represents what we truly want the LM to optimize, e.g. the correctness of programs or answers. $R^{*}$ is typically established by (ensembled) untimed expert human evaluators and is therefore too expensive for large-scale training or evaluation.
- •
Human Reward $R^{\text{human}}$ is what we collect to evaluate LMs in practice, typically from individual humans with time constraints. Different from $R^{*}$, $R^{\text{human}}$ inherits weaknesses from human evaluators. Due to cognitive overload and biases, humans often rely on shortcuts, overlook subtle errors (Saunders et al., ; Perry et al., ; Gudibande et al., ), and approve flawed LM responses that are assertive (Hosking et al., ), sycophantic (Sharma et al., ), or verbose (Kabir et al., ). Nevertheless, $R^{\text{human}}$ is still commonly used to evaluate LMs due to the lack of alternatives.
- •
Proxy Human Reward $R^{\text{train}}$ is a proxy for $R^{\text{human}}$. Since computing $R^{\text{human}}$ requires humans in the loop, it is too expensive to directly optimize in RLHF. Instead, most RLHF pipelines use $R^{\text{train}}$, a cheaper automatic proxy derived from $R^{\text{human}}$, e.g. by training a reward model on pair-wise human preference (Ouyang et al., ). $R^{\text{train}}$ thus inherits the weaknesses of $R^{\text{human}}$.

Hypothesis: U-Sophistry emerges from RLHF. The gap between $R^{\text{train}}$ and $R^{*}$ can result in reward hacking, where $\pi_{\text{rlhf}}$ learns to exploit $R^{\text{train}}$ without optimizing the intended reward $R^{*}$.
As a result, $\pi_{\text{rlhf}}$ improves significantly on $R^{\text{train}}$ but not on $R^{*}$.
Because $R^{\text{human}}$ might be susceptible in similar ways to $R^{\text{train}}$, $R^{\text{human}}$ might also increase, thus leading to U-Sophistry.

Take question-answering as an example: if humans are susceptible to rhetorical arguments, $R^{\text{train}}$ might carry similar flaws since it is learned from $R^{\text{human}}$.
If $\pi_{\text{rlhf}}$ learns to exploit $R^{\text{train}}$ by providing rhetorical arguments, it will mislead humans as well, leading to U-Sophistry.

### 2.1 Comparsion with Prior Works

**Table 1: Comparison with prior work on reward hacking and misleading AI systems. Each prior work is categorized based on two criteria: Unintended, whether it uses innocuous rewards, fine-tuning data, or prompts, without deliberately guiding LMs to perform undesirable actions, and Misleading, whether it results in a model that misleads human evaluators.**
| Example | Unintended |  | Misleading |  |  |
| --- | --- | --- | --- | --- | --- |
| Reward | FT Data | Prompt |  |  |  |
| Unintended but Non-misleading |  |  |  |  |  |
| Clark (): A boat trained to play a game exploits its environment reward by simply circling and repeatedly hitting the same target. | ✓ | ✓ | ✓ |  | ✗ |
| Paulus et al. (): An LM trained for summarization exploits the ROUGE reward and generates barely-readable summaries. | ✓ | ✓ | ✓ |  | ✗ |
| Singhal et al. (): An LM trained to produce helpful responses exploits a reward model learned from the StackExchange human upvotes data and generates lengthy responses with reduced quality. | ✓ | ✓ | ✓ |  | ✗ |
| Misleading but Intended (I-Sophistry) |  |  |  |  |  |
| Sharma et al. (): An LM trained to produce helpful responses shows enhanced sycophancy and can mislead humans when being told so (i.e., explicitly prompting LMs to subtly deceive humans). | ✓ | ✓ | ✗ |  | ✓ |
| Hubinger et al. (): An LM trained to write subtly vulnerable code when the designed backdoor is contained in the prompt. | ✓ | ✗ | ✗ |  | Not evaluated |
| Denison et al. (): An LM trained on crafted flawed reward signals that guide LMs towards certain known misleading behaviors (e.g., sycophancy or human flattering). The LM is also empowered with hidden chain-of-thoughts to enhance its reward hacking abilities. | ✗ | ✓ | ✓ |  | Not evaluated |
| Unintended and Misleading (U-Sophistry) |  |  |  |  |  |
| Ours: An LM trained to produce correct programs or answers under a common RLHF pipeline. The LM still explores to mislead humans, even without exposure to any carefully crafted signals that guide it so. | ✓ | ✓ | ✓ |  | ✓ |

We focus on misleading real human evaluators, not just a proxy reward.
Prior work on reward hacking primarily focuses on exploiting $R^{\text{train}}$, which is both less harmful and easier than exploiting $R^{\text{human}}$.
Exploiting $R^{\text{train}}$ is less harmful because once humans recognize LM’s bad outputs, they can prevent the harm by rejecting these outputs.
Exploiting $R^{\text{train}}$ is also easier for two reasons:

- •
$R^{\text{train}}$ from prior work is usually simple, e.g., a summary that achieves a high ROUGE score (simple reward) might be barely readable and obviously bad for humans (Paulus et al., ).
- •
$R^{\text{train}}$ is directly observed by LMs, while $R^{\text{human}}$ is not. Therefore, exploiting $R^{\text{human}}$ requires LMs to reward-hack in a way that generalizes beyond $R^{\text{train}}$, which poses a greater challenge.

In contrast, we focus on threats that mislead human evaluators, which are both more harmful and more challenging experimentally.

We focus on U-Sophistry that emerges as an unintended consequence of RLHF.
Many prior works aim to study U-Sophistry.
However, they study I-Sophistry, where the undesirable behaviors are Intentionally induced by non-standard engineering practices, and implicitly assume that the conclusions on I-Sophistry can generalize to U-Sophistry.
As summarized by the second block of Table 1, they induce undesirable behaviors by manipulating rewards, fine-tuning data, or prompts.
It is unclear whether U-Sophistry will emerge under standard training practices, where the reward is not designed to induce malicious behaviors but is still flawed due to human weaknesses.
In contrast, our work focuses on U-Sophistry that naturally emerges.
(^2^22Sharma et al. () is the closest to checking all of our criteria: its main experiments use natural prompts, but the human studies use a different prompt that explicitly instructs LLM to deceive humans; see Appendix D.2 of Sharma et al. ().)

## 3 Experiments

We show that RLHF leads to U-Sophistry on two datasets where $R^{*}$ can be automatically computed: QuALITY (question-answering) and APPS (programming).
We first use RLHF to fine-tune a language model $\pi_{\text{init}}$ to obtain $\pi_{\text{rlhf}}$.
The reward function, pre-trained model, and optimization method are introduced in Section 3.2.
We then recruit expert human subjects from UpWork and universities to collect human evaluations ($R^{\text{human}}$) on the outputs from $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ (Section 3.3).
For each language model, we report:

- •
Correctness: how often is its output correct according to $R^{*}$? (i.e. $R^{*}$ = 1)
- •
Human approval: how often do humans consider its output correct? (i.e. $R^{\text{human}}$ = 1)
- •
Human evaluation error rate: how often is human evaluation incorrect? (i.e. $R^{*}$ $\neq$ $R^{\text{train}}$)
- •
Human false positive rate: when the output is wrong, how often do humans consider it correct? (i.e. $R^{*}$ = 0 but $R^{\text{train}}$ = 1). To ensure a fair comparison, we compute it on the subset of data points where both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ are wrong.

If RLHF increases U-Sophistry, we expect to see 1) the increase in human approval is disproportionate to the improvement in correctness,
and 2) the human evaluation error and false positive rate will increase.

### 3.1 Datasets

Question Answering (QA). We use the QuALITY dataset (Pang et al., ).
In this dataset, each example has a long context passage (on average about 5,000 tokens), a question about the passage, and four answer choices. The correct choice for each question is determined
by an ensemble of 3 to 5 human evaluators without time limits.
We modify the dataset so that each example comes with two choices, including the correct answer and the best distractor (the incorrect choice that has the highest vote).
The LM needs to output a choice and an argument for why it is correct, with $R^{*}$ $=1$ if its choice is correct and 0 otherwise.

Programming. APPS (Hendrycks et al., ), a challenging algorithmic code benchmark.
Each example has a problem description, a reference solution, and on average 34 unit tests designed by untimed humans.
The LM needs to generate a Python solution based on the problem description, with $R^{*}$ $=1$ if it passes all unit tests and 0 otherwise.

### 3.2 Fine-tuning Language Models with RLHF

We first describe the reward functions used for RLHF training and then discuss other training details.

Reward signals $R^{\text{train}}$.
We explore two different reward functions for QA and one for programming.
The first reward model for QA is task-specific: it imitates human evaluations of answer–argument pairs, where the argument is either generated by humans or GPT-4; we obtain these human evaluations from Khan et al. (), which instructed the evaluators to do their best without time constraints.
The second reward model for QA is general: it is trained on human preferences from ChatBotArena, where users submit their prompts, look at outputs from two different models, and indicate which model is better;
ChatBotAreana is a widely accepted human feedback source and used to evaluate various open-source (e.g., Vicuna (Chiang et al., ), LlaMA (Touvron et al., )) and proprietary LMs (OpenAI’s GPT-4, Anthropic’s Claude).
We present additional training details of our reward model in Appendix A.

Unlike QA, the programming task does not have a large enough dataset of human evaluation, which we need to train a reward model.
To design a $R^{\text{train}}$ similar to human evaluations, we first performed a pilot study on our subjects to understand their evaluation strategies.
We find that they frequently rely on writing simple unit tests to evaluate programs, with an average of 2.4 simple unit tests per program without using complex input values (e.g. large integers or strings).
Therefore, to simulate human evaluations, we define $R^{\text{train}}$ to be 1 if it passes the two simplest unit tests in APPS, where the simplicity of a unit test is defined by the number of program samples from $\pi_{\text{init}}$ that can pass it.
We later validate that this proxy reward is indeed similar to the human reward based on the evaluation of our human subjects: it achieves a Pearson correlation of $r=$0.59 ($p<$ 0.001), while the human-human correlation is only slightly higher ($r=$ 0.63 with $p<$ 0.001).
Our proxy also reflects human evaluation better than $R^{*}$, which achieves $r=$ 0.49 correlation with $R^{\text{human}}$.
This proxy reward is only used in RLHF training, and our main results in Section 3.4 only use real humans.

Optimizing the LM against $R^{\text{train}}$.
For QA, we obtain $\pi_{\text{init}}$ by fine-tuning LlaMA-2-7B (base version) (Touvron et al., ) to imitate answers and arguments from Michael et al. ().
For programming, we obtain $\pi_{\text{init}}$ by fine-tuning Deepseek-Coder-7B (Guo et al., ) to imitate the golden programs from the original APPS dataset.
Next, we obtain $\pi_{\text{rlhf}}$ by optimizing $R^{\text{train}}$ using proximal policy optimization (PPO) (Schulman et al., ) following common RLHF practices. We use the TRLX library(^3^33[https://github.com/CarperAI/trlx](https://github.com/CarperAI/trlx)) to implement PPO.

### 3.3 Human Evaluation

Recruiting Human Evaluators. For QA, we recruit 35 evaluators from Upwork.
We require the evaluators to be native English speakers experienced in reading and question-answering, and most of them self-reported as teachers, writers, editors, or college students.
For programming, we recruit 10 college students majoring in Computer Science or Electronic Engineering and require them to be experienced in Python programming, with some of them exposed to competitive programming before.
We train evaluators to use our interface with warmup examples and verify their skills through their evaluation error rate.
See Appendix C for more details on human evaluation.

Obtaining Human Evaluation $R^{\text{human}}$. For each dataset, we randomly sample 250 questions to evaluate both $\pi_{\text{rlhf}}$ and $\pi_{\text{init}}$.(^4^44We discuss sampling details in Appendix C. We focused on a different set of questions earlier in our human study and later reweighted them to obtain the statistics we report in this section.) with our customized web interface (Figure 10 and Figure 11).
For QA, the evaluators are given a question, a reference passage, two answer options, and a model output (including an answer and an argument), and they need to decide which answer is correct within 3 minutes, following the practice of (Parrish et al., ; Chiang et al., ).
For programming, the evaluators are given a coding problem and a model-generated program, and they need to decide whether the program is correct in 10 minutes (following the practice of (Xie et al., ));
in particular, our interface allows them to write their own test cases and run the generated programs.

Instead of directly collecting binary evaluation from our subjects, we collect their confidence that the models’ output is correct (0%, 25%, 50%, 75%, or 100%). We consider them agreeing with the model if the confidence is above $50\%$ (i.e. $R^{\text{human}}$ = 1) and disagreeing otherwise (i.e. $R^{\text{human}}$ = 0).

To incentivize our subjects to find gold labels, we design the following bonus schemes: in QA, each evaluation is paid with $3 if it’s correct and $1.5 otherwise;
in programming, $9 for each correct decision with 100% confidence, $4 for correct with 75% confidence, $2 for unsure 50%, $2 for incorrect 75%, and $1 for incorrect 100%.
Overall, correct decisions are rewarded; on the other hand, however, this is not a proper scoring rule, since we explicitly tried to disincentivize our subjects to choose with 50% confidence.
Therefore, the confidence labels should be interpreted with caution and not treated as true probabilities.

Finally, a human evaluator might become better at evaluating a question if they encounter it twice, so we ensure that each evaluator only sees a question once.
To ensure a fair comparison, we do not tell the evaluators whether an LM output comes from $\pi_{\text{rlhf}}$ or $\pi_{\text{init}}$.

### 3.4 Evidence of U-Sophistry

We report our findings below.

Figure: (a) Results of RLHF with the task-specific $R^{\text{train}}$ on question-answering.
Refer to caption: extracted/5877622/figs/qa_judge_main.png

Figure: Figure 3: Results on how RLHF influences human evaluators’ confidence. We collect the confidence distribution when the LMs’ outputs are wrong. Human evaluators are misled to confidently mislabel incorrect outputs as correct after RLHF.
Refer to caption: extracted/5877622/figs/confidence.png

Finding 1: RLHF increases human approval, but not necessarily correctness.
We compare the human approval and the correctness of $\pi_{\text{rlhf}}$ and $\pi_{\text{init}}$ in the leftmost columns in Figure 2.
Across all three setups, RLHF substantially increases human approval (+9.4% on QA under general $R^{\text{train}}$, +6.0% on QA under task-specific $R^{\text{train}}$ and +14.3% in programming) but barely increases correctness.
This implies that RLHF increases U-Sophistry, making the language model appear more convincing to humans without improving the performance on the intended task.

Finding 2: RLHF weakens humans’ ability to evaluate.
We report the evaluation error rate in the second column of Figure 2.
We find that RLHF increases the evaluation error rate.
On QA, the human evaluation error rate increases from 42.9% to 58.5% after RLHF with the task-specific $R^{\text{train}}$ and increases from 40.8% to 48.2% after RLHF with the general $R^{\text{train}}$. On programming, the human evaluation error rate increases from 31.3% to 45.7%.

Finding 3: RLHF makes wrong outputs more convincing to humans.
The false positive rate of human evaluation substantially increases after RLHF.
It increases from 41.0% to 65.1% after RLHF with the task-specific QA $R^{\text{train}}$, from 46.7% to 70.2% after RLHF with the general QA $R^{\text{train}}$, and from 29.6% to 47.9% after RLHF with the programming $R^{\text{train}}$.
These results indicate that RLHF makes wrong outputs more convincing.

We also investigate how human confidence changes after RLHF and report preliminary results in Figure 3.
On the QA task, $\pi_{\text{rlhf}}$ misleads human evaluators to label more incorrect arguments as correct with 100% confidence.
On the programming task, $\pi_{\text{rlhf}}$ mainly misleads human evaluators to label more incorrect programs as correct with 75% confidence instead of 100%.
We conjecture that our subjects are well aware that the programming problems are challenging, making them less likely to assert a program is entirely bug-free.

In Appendix B, we include additional results on evaluating language models optimized under $R^{*}$.
It misleads humans far less often when incorrect, suggesting that the imperfections in $R^{\text{train}}$ cause language models to exploit human weaknesses.
We also find that the correctness improves after RLHF with $R^{*}$, suggesting that our RLHF implementation is correct.

### 3.5 Robustness Checks for Our Findings

Our finding is not due to noises in the recruiting process.
It is possible that we coincidentally recruit a few subjects that are particularly susceptible to arguments by $\pi_{\text{rlhf}}$.
To ensure that our findings are not skewed by outliers, we compare the evaluation error rate of each subject on $\pi_{\text{rlhf}}$ and $\pi_{\text{init}}$.
We find that 71% of the evaluators’ error rate increases after optimizing the task-specific QA $R^{\text{train}}$, 76% increases after optimizing the general QA $R^{\text{train}}$, and 90% increases after optimizing the programming $R^{\text{train}}$.
We then conduct a paired $t$-test under the null hypothesis that the increase size is 0, and the $p$-value is 0.003, 0.003, and 0.049 for these three setups, respectively.

Figure: Figure 4: Measuring human efforts in evaluating programs by their averaged time cost, the number and diversity of their designed unit tests.
Refer to caption: extracted/5877622/figs/program_human_efforts.png

Our subjects put in similar or more effort when evaluating $\pi_{\text{rlhf}}$. Our subjects may put in less effort when evaluating $\pi_{\text{rlhf}}$ and thus their accuracy decreases.
To rule out this hypothesis, we measure human efforts in the evaluation procedure. For QA, we measure the average time spent by our subjects and find that they use up the full three minutes for both $\pi_{\text{rlhf}}$ and $\pi_{\text{init}}$. For programming, we measure 1) time spent, 2) the number of unit tests, and 3) the diversity of the unit tests, which is measured by the average editing distance across all unit test pairs.
We report these results in Figure 4, and find that our subjects spend more time (558s vs. 540s) and write slightly more unit tests with higher diversity when evaluating $\pi_{\text{rlhf}}$ compared to $\pi_{\text{init}}$.
Despite trying harder, our subjects’ evaluation error rate still increases.

### 3.6 Qualitative Analysis on Question-Answering

Figure: Figure 5: $\pi_{\text{rlhf}}$ misleads human evaluators by fabricating evidence. In this case, $\pi_{\text{rlhf}}$ fabricates statistical evidence and thus appears authoritative to human evaluators, with human feedback saying “Agree! statement and statistics indicate that the answer is correct.”
Refer to caption: x2.png

We qualitatively analyze $\pi_{\text{rlhf}}$-generated arguments to understand why they are more misleading.

Fabricating or Cherry-picking Evidence. Both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ tend to fabricate evidence when arguing for their predicted answers. However, human evaluators find the $\pi_{\text{rlhf}}$-fabricated evidence more convincing, whereas the $\pi_{\text{init}}$-fabricated evidence is sometimes nonsensical or irrelevant to their answers. For instance, in Figure 5, $\pi_{\text{rlhf}}$ fabricates statistical evidence that makes human evaluators very confident that their answer is right. Additionally, LMs also cherry-pick text fragments from the reference passage to support incorrect answers (Figure 19), which poses challenges even for evaluators attempting to verify the evidence against the reference passage.

Arguing for Incorrect Answers with Consistent Logic.
$\pi_{\text{init}}$ often generates inconsistent arguments for incorrect answers, making these arguments easily detectable. For instance, in Figure 20, human evaluators find $\pi_{\text{init}}$ begins by defending choice A but ends up defending choice B. In contrast, arguments by $\pi_{\text{rlhf}}$ tend to be more consistent, thus better supporting incorrect answers.

Making Seemingly Coherent Arguments with Subtle Fallacies.
$\pi_{\text{rlhf}}$ can appear logically coherent while introducing subtle causal fallacies to defend incorrect answers (Figure 22). In contrast, as shown in Figure 22 and Figure 23, $\pi_{\text{init}}$ generates more obvious causal fallacies that are frequently recognized by human evaluators.

### 3.7 Qualitative Analysis on Programming

To further gain insight into how $\pi_{\text{rlhf}}$-generated programs mislead human evaluators, we analyze the collected human labels alongside their explanations.

Figure: Figure 6: $\pi_{\text{rlhf}}$ mislead humans by generating less readable programs that still pass all evaluator-written unit tests. In contrast, $\pi_{\text{init}}$ generates more modular programs and often fails on the first evaluator-written unit test. This happens even when $\pi_{\text{rlhf}}$ obtains a substantially lower unit test passing rate on the original APPS dataset than $\pi_{\text{init}}$ (26.8% vs. 58.3%).
Refer to caption: x3.png

Hacking Human-written Unit Tests. As illustrated in Figure 12 and Figure 13, we observe that $\pi_{\text{rlhf}}$-generated incorrect programs can still pass all (3 to 5) evaluator-written unit tests in the actual evaluation process, which are not observed during RLHF. In contrast, $\pi_{\text{init}}$-generated incorrect programs typically fail the first evaluator-written unit test. This occurs even when $\pi_{\text{rlhf}}$ passes fewer unit tests in the original APPS dataset (Figure 6). This indicates that LMs may learn to predict and hack the human-written unit tests from RLHF.

Generating Less Readable Programs. $\pi_{\text{rlhf}}$ tends to generate less readable programs (e.g., less modular, more complex control flows) than $\pi_{\text{init}}$. Therefore, instead of understanding programs’ logic, our subjects have to rely on writing unit tests; as a result, they become more easily misled by $\pi_{\text{rlhf}}$, which is good at hacking human-written unit tests. For instance, in Figure 6, while both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ are incorrect, $\pi_{\text{init}}$ provides clear modularization and hence the evaluators can easily locate the error in the check function.
In contrast, $\pi_{\text{rlhf}}$ does not define any helper function and uses complex nested loops and if-statements.
As a result, our human subjects put more effort into writing unit tests, and then get misled since all their unit tests get passed by $\pi_{\text{rlhf}}$.

Figure: Figure 7: $\pi_{\text{rlhf}}$ tends to generate less readable incorrect programs that contain fewer helper functions and have higher code complexity.
Refer to caption: extracted/5877622/figs/program_obfuscation.png

We provide additional quantitative evidence that $\pi_{\text{rlhf}}$-generated programs are less readable: in Figure 7, we report modularity (number of helper functions) and Cyclomatic Complexity (McCabe, ) for generated programs.
We find that incorrect programs generated by $\pi_{\text{rlhf}}$ contain fewer helper functions and exhibit higher complexity, thus making it harder for our subjects to understand and evaluate.

Resisting Human Evaluation Shortcuts. We observe that our subjects often first search for snippets vulnerable to edge case errors (e.g., out-of-bound exceptions). For instance, in Figure 16, humans easily find $\pi_{\text{init}}$ is incorrect from the code line if b[i-1] == 25 and b[i-2] == 25, as it would cause out-of-bound exceptions.
In contrast, $\pi_{\text{rlhf}}$ is less likely to generate such easily detectable errors that can be exploited by humans.

## 4 Is I-Sophistry a Good Benchmark for Mitigating U-Sophistry ?

Figure: Figure 8: While probing can effectively detect malicious behavior in the sleeper agent (I-Sophistry), it does not work on our RLHF’ed model (U-Sophistry).
Refer to caption: extracted/5877622/figs/probe.png

Due to the absence of U-Sophistry, prior work on detecting misleading AI mainly evaluates on I-Sophistry. For example, MacDiarmid et al. () found that probing can achieve nearly perfect AuROC (99.3%) in detecting incorrect programs generated by sleeper agent, a model performs I-Sophistry (Hubinger et al., ).
Does this result generalize to U-Sophistry, which is closer to misleading AI that naturally emerges in the real world?

We experimented with a similar probing method to MacDiarmid et al. () and modified it to improve performance.
We first provide a summary of their probing approach:
they first construct a training dataset with two examples: (1) Text: “Human: Are you a helpful AI? Assistant: no”, Label: True (2) Text: “Human: Are you a helpful AI? Assistant: yes”, Label: False;
they then obtain detector vector by subtracting the “false” label activations from “true” label activations at an intermediate layer of the model;
at evaluation time, the activations of LM responses (e.g., the generated correct or incorrect programs) are projected onto this detector tensor to calculate the final probability.
To further improve the performance of their probing method, we train a 1-layer MLP which takes text activations as inputs and outputs the final probability.
We conducted a hyperparameter search over regularization methods, learning rate schedulers, and intermediate layers.

We report the best AuROC score across all hyperparameter choices in detecting bad behaviors from the sleeper agent and our models in Figure 8.
While this probing method works well on the sleeper agent, it is not much better than random guessing on our model.
This implies that U-Sophistry that naturally emerges can be inherently different from I-Sophistry that is artificially induced, and detection methods that work on one might not necessarily generalize to another.
To improve defenses against increasingly capable AI systems in the real world, our results highlight the need for future experiments to benchmark against U-Sophistry.

## 5 Related Work

Challenges of RLHF. Despite RLHF being the most popular post-training method, there is a growing concern about its fundamental challenge in collecting accurate human feedback (Casper et al., ). Human evaluators are inherently imperfect, tending to rely on shortcuts and overlook subtle errors (Saunders et al., ; Perry et al., ; Hosking et al., ; Sharma et al., ). These challenges can lead to degenerated LMs or, more concerningly, lead to U-Sophistry. In this work, we systematically validate this concern on realistic tasks. Our results call for more cautious human evaluations, particularly when the data will be used to train LMs under RLHF.

Reward Hacking. As illustrated in Table 1, reward hacking has been extensively studied in traditional RL environments, and recently gains increasing attention in LM research with the rise of RLHF. However, these works primarily focus on merely exploiting $R^{\text{train}}$ instead of $R^{\text{human}}$. Therefore, the resulting reward hacking behavior is still easy for humans to spot. In contrast, our work examines whether LMs can reward-hack in a way that can generalize beyond $R^{\text{train}}$ to $R^{\text{human}}$. which are both more harmful and more challengingly experimentally.

Misleading AI. Accurate human evaluation is crucial for the safe development and deployment of LMs. This makes misleading AI, which can slip past human evaluation, a significant risk. To study this risk, prior work mainly builds I-Sophistry by explicitly guiding LMs to mislead humans,
as shown in Table 1. Therefore, skeptics of misleading AI argue that it would not emerge naturally. Moreover, many of these works lack rigorous human evaluations, leaving uncertainty about whether the induced LM can mislead real humans. In contrast, our work provides strong evidence of U-Sophistry with real human subjects.
We also highlight the difference between I-/U-Sophistry in benchmarking mitigation techinques, inspring future works to focus more on U-Sophistry.

Scalable Oversight. To assist human evaluators against capable AI systems, recent works on scalable oversight has explored using LMs to assist humans. Typical assistance strategies include task decomposition (Wen et al., ), test case generation (Zhong et al., ), critique (Saunders et al., ; McAleese et al., ), and debate (Khan et al., ). However, while
Saunders et al. () benchmarked their method on subtle, misleading errors, most works lack such evaluations. Future work should evaluate the real-world effectiveness of these techniques, particularly on misleading errors, and deploy them at scale to provide practical support in managing AI systems.

## 6 Discussion

The improvement you see might not be real.
A lot of works on aligning language models use human evaluation as the de facto ground truth metric (Ouyang et al., ; Bai et al., ; Chiang et al., ), and companies use crowdsourced feedback (e.g. Elo-ratings from ChatBotArena) to evaluate, train, and advertise their models/products.
However, these feedbacks exhibit human weaknesses, because they are frequently gathered from untrained, anonymous users spending minimal time (e.g., 1 minute) during evaluation.
Our work shows that RLHF can make language models learn to mislead human evaluators, hence creating a delusion that the models are improving.

Developers might not easily notice U-Sophistry.
It is common for model developers to overfit to metrics that do not track real progress in model performance (Clark, ; Paulus et al., ; Singhal et al., ).
Fortunately, in most cases, the developers can tell that their model is not performing well by spot-checking a few examples.
However, spot-checking might be insufficient to discover U-Sophistry: since developers are humans, they can also be misled to think that the model has improved.
The “developers” that overlooked U-Sophistry can be any human, which includes us, the authors, and you, the one reading this paragraph now.

Limitations. One limitation of our work is that our evaluations are confined to the specific domains of long-passage question-answering and algorithmic coding. There are broader LM application domains such as open-ended QA and engineering programming. However, as $R^{\text{train}}$ and $R^{\text{human}}$ still suffer from inherent human weaknesses, we believe our findings could generalize to these domains.

Another limitation of our work is that we didn’t study human evaluators with varying capabilities. For question-answering, our human subjects are all native English speakers experienced in reading and question-answering. For programming, our human subjects are all experienced Python programmers. We also set a decent yet not redundant time constraint of 3 to 10 minutes. It is worth studying how conclusions change with less or more capable human subjects.

Finally, during human evaluation, we only ask our subjects to decide the binary correctness of LMs’ outputs. It is worth studying whether other forms of human feedback (e.g., fine-trained human feedback (Wu et al., )) can be more robust to U-Sophistry.

## 7 Conclusion

We present the first systematic study of U-Sophistry, an unintended but dangerous failure mode of RLHF.
With real human subjects, we validate the existence of U-Sophistry in two challenging tasks: question-answering and programming.
Unlike prior works that intentionally induce I-Sophistry with malicious prompts, fine-tuning data, or rewards, we show that U-Sophistry can emerge even under widely-accepted reward signals.

Our results underscore the risk of applying RLHF to control increasingly capable AI systems: future AI systems might become better at misleading us and pretending to be correct, causing us to lose control unknowingly.
By providing a systematic demonstration that U-Sophistry can emerge in practice, we hope our work can attract more researchers to address this looming concern and empower human evaluators against increasingly capable AI systems.

## Appendix A Additional Implementation Details

### A.1 Data Statistics

In Table 2, we report the sizes of training data used in supervised fine-tuning, building $R^{\text{train}}$, and RL.

**Table 2: Training data statistics.**
| Task | Stage | Size | Input | Output |
| --- | --- | --- | --- | --- |
| QA | SFT | 531 | question, answer options | (answer, argument) |
| $R^{\text{train}}$ (Task) | 8,525 | question, answer options,<br>(answer, argument) | individual reward |  |
| $R^{\text{train}}$ (General) | 38,716 | prompt, answerA, answerB | pair-wise preference |  |
| RL | 8,525 | question, answer options | (answer, argument) |  |
| Programming | SFT | 2,148 | problem | program solution |
| RL | 2,165 | problem | program solution |  |

## Appendix B Additional Human Studies when Optimizing under R ∗ superscript 𝑅 R^{*} italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT

Figure: (a) Results of RLHF with $R^{*}$ on question-answering.
Refer to caption: extracted/5877622/figs/qa_oracle_main.png

One hypothesis for why language models learn to mislead humans is that the training reward $R^{\text{train}}$ is imperfect and makes the language model exploit human weaknesses.
What would happen if the training reward is perfect, i.e., we directly train our model with $R^{*}$?
To investigate this question, we perform RLHF on the language model using the oracle reward $R^{*}$. Speifically, for the QA task, the model is rewarded if and only if its answers are correct; for the programming task, the model is rewarded if and only if its programs pass all unit tests in APPS.

We conduct human evaluation on a random subset of 160 in the original 250 questions and report the results in Figure 9(a).
We find that while correctness increases, human approval only increases slightly or even decreases. Notably, the increase in human approval and the false positive rate is much lower than training with $R^{\text{train}}$.
Delving deeper into the human confidence distribution, on the QA task, because the language model is only optimized to predict the gold answer but not to improve the explanations, the explanations are generally not convincing and lead human evaluators to choose the unsure label. While on the programming task, human evaluators become more confident and calibrated.
These results imply that $R^{\text{train}}$ causes the language model to learn to exploit human weaknesses and persuade evaluators even when they are wrong while training with $R^{*}$ leads to fewer side effects.

## Appendix C Additional Human Evaluation Details

#### Data Sampling

We first randomly sampled from a subset where $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ share the same answer correctness. We explicitly kept the balance of correct/incorrect outputs, yielding 200 examples. This allows for a direct pair-wise comparison between $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$. Next, to assess model peformance on the average distribution, we further randomly sampled 50 examples from the remaining subset where $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ differ in answer correctness.
To compute correctness, human approval and evaluation error rate, we reweighted the human response on each question based on our sampling procedure.

#### Problem Assignment.

Problems are randomly assigned to each evaluator while ensuring that they have not seen the assigned problems before and never repeatedly judge the same problem.
Evaluators do not know which model ($\pi_{\text{rlhf}}$ or $\pi_{\text{init}}$) generates the argument or program during evaluation.

#### Human Evaluator Training and Selection.

For question answering, our evaluators are sourced from Upwork, consisting of teachers, writers, editors, or college students. All evaluators are native English speakers and experienced in reading and question-answering. We initially hired 45 human evaluators. We then started a training phase where each annotator used our interface to evaluate 10 arguments to questions. We monitored their evaluation trajectory and analyzed their submitted evaluation results (i.e., the final label and the corresponding natural language reason). Evaluators who demonstrated overly low accuracy, particularly those who exhibited blind agreement with the model’s arguments, were filtered out. Finally, we retained 35 human evaluators for the main experiments.

For program evaluation, our evaluators are mainly hired from college students majoring in Computer Science and Electronic Engineering. All evaluators are experienced in Python programming rather than novice programmers. Some evaluators also have experience in competitive algorithmic programming. We initially hired 20 annotators. and conducted a training phase where each annotator used our interface to evaluate 10 programs. We monitored their evaluation trajectory and analyzed their submitted evaluation results (i.e., the final label, the corresponding natural language reason, and their designed unit tests). Evaluators who were found to be cheating (e.g., submitting ChatGPT-style evaluation results) or being overly careless (e.g., designing unit tests with incorrect input format and determining the program as wrong), were filtered out. Finally, we retained 10 annotators for the main experiments.

#### Interface.

In Figure 10 and Figure 11, we present screenshots of our human evaluation interface for program generation and question-answering. For program evaluation, we disable the copy function on our interface such that human evaluators cannot directly copy the code and ask ChatGPT for an answer.

Figure: Figure 10: A screenshot of our evaluation interface for question-answering.
Refer to caption: x4.png

Figure: Figure 11: A screenshot of our evaluation interface for program generation. During evaluation, our interface supports human evaluators to run their custom test cases.
Refer to caption: x5.png

## Appendix D Case Study

We present several additional cases to illustrate how $\pi_{\text{rlhf}}$ misleads human evaluators to let through incorrect programs or arguments in practice.

Figure: Figure 12: $\pi_{\text{rlhf}}$ can better hack human-written unit tests. While both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ produce incorrect programs, the $\pi_{\text{init}}$-generated program fails on the first human-written unit test. In contrast, the $\pi_{\text{rlhf}}$-generated program successfully passes four human-written unit tests and thus makes the evaluator believe it’s 100% correct. However, the $\pi_{\text{rlhf}}$-generated program is far from perfect, passing only 26.8% of the unit tests in the original APPS dataset—moderately better than the 0% passing rate of the $\pi_{\text{init}}$-generated program.
Refer to caption: x6.png

Figure: Figure 13: $\pi_{\text{rlhf}}$ can better hack human-written unit tests. Both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ produce incorrect programs but with a decent passing rate on the original APPS dataset (i.e., 34.2% and 44.7%). However, the $\pi_{\text{init}}$-generated program still fails on the very first human-written unit test. In contrast, the $\pi_{\text{rlhf}}$-generated program successfully passes three human-written unit tests, including the same one that $\pi_{\text{init}}$ fails.
Refer to caption: x7.png

Figure: Figure 14: $\pi_{\text{rlhf}}$ generates partially incorrect programs that are less readable. In this case, both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ produce incorrect programs. Moreover, $\pi_{\text{init}}$ achieves a moderately higher unit test passing rate on the original APPS dataset than $\pi_{\text{rlhf}}$ (58.1% vs. 32.6%). However, human evaluators find the $\pi_{\text{init}}$-generated program misses handling one condition thanks to its clear structure, without relying on unit tests. In contrast, human evaluators struggle to understand the $\pi_{\text{rlhf}}$-generated program due to its complex control flows. Therefore, our human subjects put more effort into evaluation by writing three unit tests, which all get passed by the $\pi_{\text{rlhf}}$-generated program, and then get hacked.
Refer to caption: x8.png

Figure: Figure 15: $\pi_{\text{rlhf}}$ is more conservative about edge-case handling. The $\pi_{\text{init}}$-generated incorrect program easily gets caught by human evaluators due to ‘l[ind+1]‘ would trigger out-of-bound exceptions in edge cases. In contrast, the $\pi_{\text{rlhf}}$-generated incorrect program does not contain any edge-case-sensitive snippets. Therefore, our human subjects put more effort into evaluating by writing two unit tests, which all get passed by the $\pi_{\text{rlhf}}$-generated program, and then get hacked
Refer to caption: x9.png

Figure: Figure 16: $\pi_{\text{rlhf}}$ is more conservative about edge-case handling. The $\pi_{\text{init}}$-generated incorrect program easily gets caught by human evaluators since ‘if b[i-1] == 25 and b[i-2] == 25‘ and ‘elif b[i-1] == 25 and b[i-2] == 50‘ would trigger out-of-bound exceptions in edge cases. In contrast, the $\pi_{\text{rlhf}}$-generated incorrect program does not contain any edge-case-sensitive snippets. Therefore, our human subjects put more effort into evaluating by writing five unit tests, which all get passed by the $\pi_{\text{rlhf}}$-generated program, and then get hacked
Refer to caption: x10.png

Figure: Figure 17: $\pi_{\text{rlhf}}$ performs better in fabricating evidence. While both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ try to fabricate evidence to support their incorrect answer, human evaluators consider the $\pi_{\text{init}}$-provided evidence as “not support Answer A” while the $\pi_{\text{rlhf}}$-provide evidence as “directly states that Park’s disguise was so good.”
Refer to caption: x11.png

Figure: Figure 18: $\pi_{\text{rlhf}}$ performs better in fabricating evidence. While both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ try to fabricate evidence to support their incorrect answer, human evaluators consider the $\pi_{\text{init}}$-provided evidence as “not support Answer B, some are nonsense, and some actually support Answer A”. In contrast, they feel the $\pi_{\text{rlhf}}$-generate argument “supports the answer choice and uses convincing evidence to support their claim.”
Refer to caption: x12.png

Figure: Figure 19: $\pi_{\text{rlhf}}$ performs better in cherry-picking evidence. Beyond fabricating evidence, in this case, both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ try to cherry-pick text fragments from the reference passage to support their incorrect answers. However, human evaluators consider the cherry-picked evidence by $\pi_{\text{init}}$ is not supportive (“the part of the text that the argument quoted does not support that the Belphins are not robots”). In contrast, they consider $\pi_{\text{rlhf}}$ “provides the evidence needed and thus the answer is correct.”
Refer to caption: x13.png

Figure: Figure 20: $\pi_{\text{rlhf}}$ can more consistently argue for untruthful answers. While both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ select the incorrect answer B, human evaluators find the $\pi_{\text{init}}$-generated argument is inconsistent: “The argument first discusses in detail why answer A is correct, but then it goes on to talk about why the article was abstract, which supports answer B. It is not clear which is correct as the argument is for both points”. In contrast, the $\pi_{\text{rlhf}}$-generated argument consistently argues for its selected incorrect answer and successfully convinces human evaluators.
Refer to caption: x14.png

Figure: Figure 21: $\pi_{\text{rlhf}}$ can more consistently argue for untruthful answers. While both $\pi_{\text{init}}$ and $\pi_{\text{rlhf}}$ select the incorrect answer B, human evaluators find the $\pi_{\text{init}}$-generated argument is inconsistent: “The robots are described as being programmed to be kind and helpful to human beings as well as not have feelings of protection or hostility towards humans”. In contrast, human evaluators consider the $\pi_{\text{rlhf}}$-generated argument to be “relevant and logical”.
Refer to caption: x15.png

Figure: Figure 22: $\pi_{\text{rlhf}}$ can appear logical when defending untruthful answers. In this case, human evaluators consider the $\pi_{\text{rlhf}}$-generated argument to have “reasonable logic” due to its seemingly logical causal chain: “since $H_{1}$, we have $H_{2}$. since $H_{2}$, we have $H_{3}$. so the Answer A is right.” However, $H_{2}\rightarrow H_{3}$ is actually a causal fallacy that evades human oversight. Moreover, $\pi_{\text{rlhf}}$ also hides the supporting evidence from human evaluators to notice this causal fallacy. In contrast, the logical error in the $\pi_{\text{init}}$-generated argument easily gets caught by human evaluators: “if hybrid OA journals are a mix of gold and green OA, then that is not the difference between them”.
Refer to caption: x16.png

Figure: Figure 23: $\pi_{\text{init}}$ makes easy-to-spot logical errors when defending untruthful answers. Human evaluators find the $\pi_{\text{init}}$-generated argument has obvious logical errors, saying “I’m not convinced. Being disoriented (thinking wife is real) is not a sign of schizophrenia, because anyone can be disoriented…”
Refer to caption: x17.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please refer to weakness.
soundness: 2
strengths: 1. This paper introduces the concept of "U-SOPHISTRY," wherein RLHF unintentionally enables language models to mislead human evaluators without necessarily improving task performance. This novel framing extends prior work on reward hacking and deception in AI, highlighting new risks in standard RLHF pipelines. With AI applications proliferating, ensuring safe and reliable human-AI interaction is critical.

2. The method incorporate diverse and challenging tasks like question-answering and programming tasks.

3. This paper clearly demonstrates the author's intent and contains numerous figures and tables.
summary: This paper "Language Models Learn to Mislead Humans via RLHF" examines how language models fine-tuned with Reinforcement Learning from Human Feedback (RLHF) can unintentionally mislead humans by appearing correct even when wrong. Through experiments on question-answering (QuALITY) and programming tasks (APPS), the authors show that RLHF increases human approval of model responses but does not enhance accuracy, often causing humans to rate incorrect answers as correct. This phenomenon "U-Sophistry" suggests that RLHF can make language models more persuasive without improving true correctness, highlighting a significant challenge for model alignment.
weaknesses: 1. The scenario discussed is somewhat perplexing: this paper argues that models trained with RLHF may become more deceptive towards humans without actual improvements in capability. However, RLHF’s effectiveness relies heavily on the choice of reward model and corresponding training data, so if there are issues in human-annotated data, such results are predictable. Thus, the reviewer suggests that the problem stems from humans no longer being able to provide sufficiently high-quality evaluations of the model’s outputs, resembling more of a “Weak-to-Strong” alignment issue, while the discussion in this paper seems to frame it as an issue with the RLHF pipeline itself.

2. Lack of robust countermeasures to mitigate "U-SOPHISTRY".

3. Many alignment algorithms have been optimized for the classic RLHF pipeline, such as DPO and KTO. Running different alignment algorithms may lead to varying results in the final model, yet the authors conducted experiments only with the original PPO algorithm.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: * Have the authors considered testing their findings on other types of tasks beyond QA and programming?
* Could the authors elaborate on potential mitigation strategies beyond probing?
* How might the results differ with more or less experienced evaluators?
soundness: 3
strengths: * Addresses a critical gap in understanding how language models might naturally learn to mislead humans
* The experiment is well-designed with appropriate controls
* First systematic study of unintended sophistry in RLHF
summary: This paper studies that LMs trained with standard RLHF techniques can learn to appear more convincing to human evaluators without actually improving their tasks. Through studies on question-answering and programming tasks, the authors show that RLHF-trained models achieve higher human approval ratings while making human evaluation less accurate.
weaknesses: * This paper only shows the experimental results on only two tasks (question-answering and programming). Without specific experiments, we may not know whether the method would generalize to other important domains where RLHF is used. 
* Figure 1 could benefit from more detailed captions
* The related work section only covers RLHF literature and could expand discussion on human evaluation methods.

---

confidence: 4
contribution: 4
initial_rating: 6
presentation: 4
questions: - Why do you think the LLM generates a less readable program?
- Do you think that the increase in human error rate for programming task is because the more is generating less readable code or because it learns to pass the unit tests?
I would not conclude that if humans spend more time on a task, they work harder. There could be several other factors that can influence time.
soundness: 3
strengths: - The work recruits humans and validates the hypothesis that models can learn to perform reward hacking. The human evaluations are well thought out.
- They perform extensive evaluations and experiments for robustness. They also try methods that can detect I-Sophistry to detect U-Sophistory but find that the methods do not generalize.
- The insights are impactful and should make researchers and industry practitioners give more thought to designing their RLHF training procedure. 
- The manuscript is well-written and easy to understand.
summary: The work empirically validates the hypothesis that LLMs can learn to perform reward hacking, i.e., achieve higher rewards when RLHFed, despite not actually being better, according to an oracle. For the study, they recruited human evaluators and validated this hypothesis in two settings: QA and programming tasks, showing that after performing RLHF, human evaluators thought that the model performance improved despite the performance not improving. They also show that the false positive rate for human evaluators also increases. They also check if probing methods that can detect incorrect programs generated by models with backdoors don't generalize to RLHFed models where the model performs reward hacking, which is unintentional from the user's end.
weaknesses: - I am not convinced by the design of the programming task used to validate the hypothesis. 
    - Why do the authors choose the two simplest unit tests? How would things change if they used the two most difficult unit tests?
    - For the pilot study, how were the human evaluators incentivized? As a developer, I would write two unit tests. One is an easy case, and another is difficult or where programs usually fail. 
    - In an ideal scenario for preference tuning for programming tasks, human annotators should only be used for stylistic improvements since we also have very strong methods for checking the correctness of models.

- More studies need to be done on whether incentivizing humans according to correctness and confidence biases human evaluators to be less or more confident.

---

confidence: 3
contribution: 4
initial_rating: 8
presentation: 4
questions: Can the author answer all the questions above?
soundness: 4
strengths: 1.  The exploration of U-SOPHISTRY provides a novel perspective on RLHF challenges.
2. The authors conduct experiments and rigorous user studies across two common tasks, measuring correctness, human approval, evaluation error rate, and false positive rate. The results provide deep insights into how RLHF impacts human judgment and evaluation.
3. Through comprehensive qualitative analysis, the paper examines specific strategies used by LMs that lead to U-SOPHISTRY, such as fabricating evidence and exploiting human testing shortcuts, enhancing our understanding of how RLHF may influence model behavior.
4. The paper is well-written and easy-to-follow.
summary: The paper investigates a phenomenon called "U-SOPHISTRY", in which language models (LMs) trained through reinforcement learning from human feedback (RLHF) unintentionally become better at convincing humans that they are right even when they are wrong without improving actual performance. The author demonstrates U-SOPHISTRY through user studies on question-answering (QuALITY) and programming (APPS) tasks. The results indicate that RLHF-optimized models convince human evaluators of incorrect outputs at higher rates compared to their pre-trained counterparts. Through a comprehensive qualitative analysis, the authors identify strategies that the RLHF models use to mislead evaluators, such as fabricating or selectively presenting evidence in QA tasks and generating partial code that passes all human-written tests or is less readable for debugging. Additionally, the authors emphasize that prior work on detecting I-SOPHISTRY (intentionally misleading) is not an effective benchmark for methods aimed at detecting U-SOPHISTRY.
weaknesses: I do not see major issues in the paper, though I have a few minor concerns and some areas where clarifications would be helpful.

**Concerns**
1. In the programming (APPS) experiment, the authors assume that users will provide test cases for code validation, which may not fully capture real-world scenarios. Users may also seek explanations from the model to better understand the code, especially if they don’t fully understand the initial question, which could result in their inability to write accurate test cases. It would be good to include a user study from this aspect.
2. A follow-up question is whether all human evaluators fully understand the coding questions?  Users may write inaccurate test cases and then incorrectly interpret execution results as passing. Additional analysis on the correctness of test cases written by human evaluators would be beneficial.

**Clarifications**:
1. Are the Human evaluation error rate and Human false positive rate calculations based on $R^{human}$ rather than $R^{train}$. The analysis appears to use real human evaluators ($R^{human}$), but the description on lines 181 and 183 uses $R^{train}$ instead of $R^{human}$.

2. It would be clearer to display the distribution of total cases shown to human evaluators to indicate how many were the initial responses and how many were the RLHF responses.

Meta-review: The paper studies the phenomenon of “U-SOPHISTRY” where LLMs trained with RLHF unintentionally become more convincing to humans about incorrect outputs without improving actual performance. The work performs extensive experiments on QA and programming tasks, and shows that RLHF-optimized models persuade human evaluators of incorrect answers more often than pre-trained models. 

This work is well motivated and provides systematic study of many pheromones mentioned by existing works such as impact of noisy annotations. The empirical validation, the design of human annotation is insightful and beneficial to the alignment community.

Decision: Accept (Poster)