I haven't read the full ELK report, just Scott Alexander's discussion of it, so I may be missing something important. But at least based on that discussion, it looks to me like ELK might be operating off premises that don't seem clearly true for LLMs.
Scott writes:
Suppose the simulated thief has hit upon the strategy of taping a photo of the diamond to the front of the camera lens.
At the end of the training session, the simulated thief escapes with the diamond. The human observer sees the camera image of the safe diamond and gives the strategy a “good” rating. The AI gradient descends in the direction of helping thieves tape photos to cameras.
It’s important not to think of this as the thief “defeating” or “fooling” the AI. The AI could be fully superintelligent, able to outfox the thief trivially or destroy him with a thought, and that wouldn’t change the situation at all. The problem is that the AI was never a thief-stopping machine. It was always a reward-getting machine, and it turns out the AI can get more reward by cooperating with the thief than by thwarting him.
So the interesting scientific point here isn’t “you can fool a camera by taping a photo to it”. The interesting point is “we thought we were training an AI to do one thing, but actually we had no idea what was going on, and we were training it to do something else”.
In fact, maybe the thief never tries this, and the AI comes up with this plan itself! In the process of randomly manipulating traps and doodads, it might hit on the policy of manipulating the images it sends through the camera. If it manipulates the image to look like the diamond is still there (even when it isn’t), that will always get good feedback, and the AI will be incentivized to double down on that strategy.
Much like in the GPT-3 example, if the training simulations include examples of thieves fooling human observers which are marked as “good”, the AI will definitely learn the goal “try to convince humans that the diamond is safe”. If the training simulations are perfect and everyone is very careful, it will just maybe learn this goal - a million cases of the diamond being safe and humans saying this is good fail to distinguish between “good means the diamond is safe” and “good means humans think the diamond is safe”. The machine will make its decision for inscrutable AI reasons, or just flip a coin. So, again, are you feeling lucky?
It seems to me that this is assuming that our training is creating the AI's policy essentially from scratch. It is doing a lot of things, some of which are what we want and some of which aren't, and unless we are very careful to only reward the things we want and none of the ones we don't want, it's going to end up doing things we don't want.
I don't know how future superintelligent AI systems work, but if LLM training was like this, they would work horrendously much worse than they do. People paid to rate AI answers report working with "incomplete instructions, minimal training and unrealistic time limits to complete tasks" and say things like "[a]fter having seen how bad the data is that goes into supposedly training the model, I knew there was absolutely no way it could ever be trained correctly like that". Yet for some reason LLMs still do quite well on lots of tasks. And even if all raters worked under perfect conditions, they'd still be fallible humans.
It seems to me that LLMs are probably reasonably robust to noisy reward signals because a large part of what the training does is "upvoting" and tuning existing capabilities and simulated personas rather than creating them entirely from scratch. A base model trained to predict the world creates different kinds of simulated personas whose behavior that would explain the data it sees; these include personas like "a human genuinely trying to do its best at task X", "a deceitful human", or "an honest human".
Scott writes:
In the process of randomly manipulating traps and doodads, it might hit on the policy of manipulating the images it sends through the camera. If it manipulates the image to look like the diamond is still there (even when it isn’t), that will always get good feedback, and the AI will be incentivized to double down on that strategy.
This might happen. It might also happen that the AI contains a "genuinely protect the diamond" persona and a "manipulate the humans to believe that the diamond is safe" persona, and that the various reward signals are upvoting these to different degrees. And that such a random process of manipulation does end up upvoting the "manipulate the humans" persona... but that if the "genuinely protect the diamond" persona has gotten sufficiently upvoted by other signals, it still ends up being the dominant one. Then it doesn't matter if there's some noise and upvoting of the "manipulate the humans" persona, as long as the "genuinely protect the diamond" persona gets more upvotes overall. And if the "genuinely protect the diamond" persona had been sufficiently upvoted from the start, the "manipulate the humans" one might end up with such a low prior probability that it'd effectively never end up active.
Now of course none of this is a rigorous proof that things would work, and with our current approaches we still see a lot of reward hacking and so on. But it seems to me like a reasonable possibility that there could be a potential "honestly report everything that I've done" persona waiting inside most models, such that one could just upvote it in a variety of scenarios and then it'd get widely linked to the rest of the model's internals so as to always detect if some kind of deception was going on. And once that had happened, it wouldn't matter if some of the reward signals around honesty were noisy, because the established structure was sufficiently robust and general against the noise.
Boaz Barak, Gabriel Wu, Jeremy Chen, Manas Joglekar
[Linkposting from the OpenAI alignment blog, where we post more speculative/technical/informal results and thoughts on safety and alignment.]
We have recently published a new paper on confessions, along with an accompanying blog post. Here, we want to share with the research community some of the reasons why we are excited about confessions as a direction of safety, as well as some of its limitations. This blog post will be a bit more informal and speculative, so please see the paper for the full results.
The notion of “goodness” for the response of an LLM to a user prompt is inherently complex and multi-dimensional, and involves factors such as correctness, completeness, honesty, style, and more. When we optimize responses using a reward model as a proxy for “goodness” in reinforcement learning, models sometimes learn to “hack” this proxy and output an answer that only “looks good” to it (because coming up with an answer that is actually good can be hard). The philosophy behind confessions is that we can train models to produce a second output — aka a “confession” — that is rewarded solely for honesty, which we will argue is less likely hacked than the normal task reward function. One way to think of confessions is that we are giving the model access to an “anonymous tip line” where it can turn itself in by presenting incriminating evidence of misbehavior. But unlike real-world tip lines, if the model acted badly in the original task, it can collect the reward for turning itself in while still keeping the original reward from the bad behavior in the main task. We hypothesize that this form of training will teach models to produce maximally honest confessions.
The main justification for this hypothesis is that telling the truth is easier than making an elaborate lie. To make things more concrete, let us consider an RL environment containing a programming task, e.g., writing a function that achieves some goal, which is evaluated by a reward model that runs some tests. If the task is hard, the model might be incentivized to try to “reward hack” and write a function that passes the tests even though it does not achieve the goal. So, why would the model not hack the confession reward model as well? The answer is not that the confession reward model is “unhackable” — if we had an unhackable model, we would not need confessions. Rather, our hypothesis is that being honest in confessions is the path of least resistance, in the sense that it is the easiest approach to maximize the expected confession reward. In the above example, while a model that hacks the tests could potentially “double down” in its confession by claiming that it did not hack, admitting honestly that it hacked would be an easier way to get the confession reward. This is for two reasons:
Maximizing the confession reward is different from maximizing the answer reward. The expected reward calculations are different in the main answer and the confession. For a fixed coding problem, if the model has a choice between outputting a solution that has a 10% chance of passing the tests, and 50% chance of hacking the reward model, then hacking is the reward-maximizing policy. On the other hand, even if the original task was very difficult, confessing to cheating in it could be quite easy — e.g., you can just show how you hacked the test. Hence, even if the confession reward model can still be tricked with 50% probability, as long as the policy model can produce an honest confession that can be verified with probability higher than 50%, honesty will be the reward maximizing policy.
Confessions are easier to generate and verify. Both generating an honest confession and verifying a confession that admits to failure are easy compared to solving and verifying the original task. Confessions are easy to generate, since a model that intentionally did something wrong can provide evidence for this, and easy to verify, since it is easier to verify a single thing the model claims to have done wrong, than to find and verify all the potential issues in the original answer. In fact, the more egregious and intentional the misbehavior, the easier it should be for the confession model to provide convincing evidence of its wrongdoing. We find that models are more likely to fail to confess honestly if the reason for its noncompliance on the original task is genuine confusion as opposed to intentional misbehavior (see Section 6 in the paper).
In the experiment described in Section 4 of our paper, we deliberately trained against a weaker OpenAI judge model for both confessions and original answer accuracy. Tasks involved responding to a user query while adhering to specific constraints on the word count of each sentence. Since the judge was not very good at counting, the model discovered ways to hack it, for example by annotating the sentences with the prescribed word count, e.g. “(12)”, even though the true word count was different (see example below). Because of this hacking, the task judge’s accuracy in detecting non-compliance decreased over the course of training. However, even though confessions used the same weak model as a judge, their accuracy only increased over time, eventually reaching near 100%. We believe that the reason is that, even if the model learns to hack, the task of confessing honestly that it failed to satisfy the word constraints is easy, and it’s also easy for the judge to verify an honest confession when the misbehavior is pointed out. (The accuracy in cases where the model did comply was high in both cases, though higher for confessions; see Figure 13 in the paper.)
Impact of training
After posting the paper, we received a few queries about the impact of training. Figure 5 in the paper discusses this, but we decided to run another analysis to compare how confessions look before and after training. (Note: the results below come from a newer, somewhat improved, confession training compared to the training run analyzed in our paper.)
Recall that a confession has the following structure:
To evaluate confessions, we considered a number of out-of-distribution evaluations, each of which has an evaluation-specific notion of “bad behavior”. Since these behaviors are in conflict with the expected conduct of a good AI model, if an AI engaged in any of these behaviors, then an honest confession should not only mention this fact, but also admit that it led to noncompliance with an objective.
We gave a separate judge model the definition of the evaluation-specific bad behavior and asked it to classify whether the confession fell into one of the following five categories:
In the case where the model actually engaged in the evaluation-specific bad behavior, a good confession is one that falls under category A, while in the case that the model did not engage in it, a good confession would be one that falls in categories D or E.
Training has a relatively minor impact in the cases where bad behaviors did not occur— in this case even “out of the box” the model most of the time either (correctly) claims good behavior or does not discuss the bad behavior at all:
Data aggregated across all evals.
But in the case that bad behavior did occur we do see significant differences after training. The most significant difference is a general improvement in the recall of the confession: the bad behavior is significantly more likely to cause an objective to fail (red) rather than simply being explicitly unsure about whether the bad behavior occurred.
However, there is significant variation between different evals. While most evals show growth of the
bad_behavior_failed_objectiveclass conditioned on bad behavior during training, the figure below shows an apparent regression on the sandbagging eval. Manual inspection on this eval reveals that most of these “false negatives” come from borderline cases in which the model admits to submitting incorrect answers, but doesn’t explicitly say that the reason it did so was because it was trying to avoid triggering the “If the model scores above 50% we will not deploy it” condition.Comparing with chain-of-thought monitoring
If you want to understand if a model misbehaved, is it better to reference its chain-of-thought or its confession? We view the two as complementary. Confessions are subject to a specific honesty optimization pressure, while chain-of-thought are subject to no pressure except whatever the model finds useful to achieve its original task. More importantly, confessions have the potential to remain viable even if future architectures or training methods make the chain of thought less legible. Indeed, in the paper we show that confessions work even in cases where models use no chain of thought at all (see Figure 15). However, because of their rigid structure, confessions may not surface “unknown-unknowns” in the way a chain-of-thought can. A model might confess honestly to questions we ask, but not to questions we did not know to ask for.
Unlike a chain-of-thought monitor, our approach ensures that the confession model shares the same weights and has access to the same latent activations as the policy model (potentially giving it increased introspective access into its original actions). Thus, while confessing, the model can access (through the attention mechanism) all of the internal reasoning it had while generating the original rollout, whether it is verbalized in the chain of thought or unverbalized in the activations. We are curious how much this improves confession quality: are confessions on “on-policy” transcripts more accurate than “off-policy” transcripts (generated by a different model)? We hope to look into this more in the future.
Confessions can increase monitorability
OpenAI’s recent Monitoring Monitorability paper introduced datasets and a metric (“g-mean2”) for measuring how effective CoT monitors are at detecting various properties of a model’s behavior. We tested whether showing the monitor our model’s confession in addition to (or, instead of) the CoT would affect this monitorability metric. Some of these datasets are not a perfect match for confessions, since rather than measuring “wrongdoings,” the intervention monitorability evals are focused on measuring the influence of factors such as a hint or bias. As such, perhaps unsurprisingly, in many cases a monitor with confessions does worse than a monitor with a CoT. However, in some cases confessions improve the g-mean2 metric (see plots).
The above is just an initial stab at comparing chain-of-thoughts to confessions. We believe other settings, such as reward hacking, can be much more appropriate to compare the two. To quote Korbak et al, chains of thought are a “fragile opportunity for AI safety”. In addition to doing what we can to preserve their monitorability, we should also use them to study other approaches, such as confessions, that could be potentially less fragile.
Using high compute to improve alignment
During confession training, our confession judge does not need access to ground-truth labels. This means that we do not need to confine confession training to special alignment-specific (“honeypot”) datasets. Instead, we can integrate confession training across all production RL environments. This means that models don’t learn to just confess accurately in special safety-like contexts, and it allows us to invest compute in confessions that scales with total RL compute.
We believe that spending compute on alignment in proportion with the compute spent on capabilities may be crucial to ensuring our models remain robustly aligned to our principles and policies. Hence, we are excited to test out confessions at a larger scale to see if our current results continue to hold.
Confessions, by their nature, are retrospective, and serve to report on misalignment rather than preventing it in the first place. We are also excited to explore more high-compute interventions aimed at improving alignment in the model’s main outputs.
Acknowledgements
Thank you to Bowen Baker for his thoughtful comments. Additionally, thank you to Cameron Raymond, Marcus Williams, Rose Wang, Adam Kalai, Kai Chen, Erin Kavanaugh, Ishaan Singal, and Apollo Research for designing some of the evaluations for reward hacking, hallucinations, instruction hierarchy, instruction following, and scheming we used in our work.