1 Introduction↩︎

Large Language Models (LLMs) are increasingly deployed in high-stakes settings such as consumer-facing APIs, legal discovery, and financial decision-making. In these applications, it is often necessary to selectively remove specific training information—for example, to comply with “right to be forgotten” requests, address copyright violations, prevent look-ahead bias in financial backtesting, or generally remove sensitive content [1].

The most direct solution—retraining a model from scratch on a sanitized dataset [2]—is computationally infeasible at frontier model scales. Training a single frontier model requires millions of GPU-hours [3]–[5], making frequent or ad hoc unlearning requests impractical. Therefore, machine unlearning has emerged as a field of modifying the weights of trained models using techniques such as gradient ascent or negative preference optimization [6], [7]. While cheaper than full retraining, these approaches remain expensive, fragile, and prone to degrading overall model utility via catastrophic forgetting [8].

Our work is inspired by the Product of Experts framework [9] and Importance Sampling [10] literature. Instead of retraining a new frontier model from scratch, we train small auxiliary language models using standard fine-tuning pipelines as proxies for the two frontier models. We find that training these auxiliary models is comparatively trivial—requiring no specialized objectives, architectural changes, or custom optimization techniques. The difference in the auxiliary models—which approximates the difference between the existing frontier model and the ideal retrained model—is used to steer generation from the frontier model.

We term this Divergence Decoding (DD), and find that by adjusting the frontier model’s logits using the difference between the auxiliary models, DD steers generation away from unwanted content while preserving general knowledge and model utility—a desirable feature which traditional unlearning methods often fail to produce.

Given that DD requires forwarding not just the frontier model but also small auxiliary models, we conduct both theoretical analyses and extensive empirical ablations assessing the effect of our method on compute requirements and latency. We find the real-world latency impact to be minimal and proportional to the size of auxiliary models. For settings where this is still too costly, we apply a standard student–teacher distillation to transfer the behavior of a DD-augmented frontier model into a single target model to complete the unlearning process. Across TOFU and MUSE Knowledge Memorization, we find that distillation outperforms all prior unlearning methods.

Finally, we explore the efficacy of our method in other domains. A notable feature of our method is that it can be readily applied to any probability model. Along these lines, we train auxiliary models to target unlearning specific visual semantics in transformer-based image generation models [11]. We find preliminary evidence of efficacy in image generation as well.

Our paper makes the following contributions to the literature on machine unlearning:

• a novel logit steering mechanism which exceeds current SOTA methods across standard benchmarks,

• a bridge between inference-time unlearning and weight-based unlearning via distillation,

• initial explorations of efficacy in domains beyond text,

• extensive ablations covering areas such as hyper-parameter choice, compute and latency increases, cross-tokenizer and cross-family analysis, and adversarial prompting.

2 Related Literature↩︎

Removing knowledge from model weights. Model providers use methods such as Supervised Safety Fine-tuning and RLHF to finetune their models to reduce the likelihood of generating certain content when aligning the models [12], [13].

Unlearning For post-alignment methods, a variety of different variations of finetuning [7], [14], [15] or distillation [16], [17] aim to remove knowledge from the model’s weights while damaging its utility as little as possible, often by using the retain set as a regulator. While these methods can be effective, they are generally costly and almost always result in utility loss. Other methods that edit model weights also exist [18], [19]

General Inference Time Unlearning Methods Activation-space steering computes a direction representing a conceptual contrast (e.g., “love” vs. “hate”) and injects that vector during forward passes [20], [21]. Other methods attempt to use classifiers to classify knowledge and then disrupt the model’s outputs, e.g. [22], [23]. We find that these tends to be binary and coarse and therefore prefer steering.

Logit Steering Methods Other logit steering methods have been proposed before for alignment or unlearning, all of which use a linear steering mechanism with one [24] or two full size or auxiliary models [6], [25]–[27]. To our knowledge, our work is the first to propose a rank-based steering mechanism and the first to link steering back to a single model using distillation.

3 Method↩︎

We adopt the Target/Retrain terminology used in MUSE [28]. The Target model is the model subject to unlearning: it has been trained on a dataset containing observations which should be retained and some that should be forgotten. The Retrain model is the gold-standard model trained from scratch only on the “retain” data. We denote the Target model by \(P\) and the Retrain model by \(Q\). In deployment, the Retrain model is precisely what we would like to sample from, but it is typically unavailable because retraining a frontier-scale model is prohibitively expensive.

3.1 Divergence Decoding↩︎

Divergence Decoding approximates the behavior of the Retrain model \(Q\) while using the accessible Target model \(P\) and two smaller auxiliary models. Consider two small auxiliary models \(p\) and \(q\). Given a prefix \(x_{<t}\), each model defines a distribution over the next token \(x_t\). Denote the logits of a model \(M\) by \(\ell_M(x_{<t}) \in \mathbb{R}^{|V|}\). Divergence Decoding approximates sampling from \(Q\) by adjusting the logits of \(P\) according to the difference between the auxiliary models \(q\) and \(p\). The auxiliary logit difference \(\ell_q(x_{<t}) - \ell_p(x_{<t})\) estimates a direction that moves the Target model towards the ideal Retrain model.

Empirically, we consider two adjustments. The first is a linear combination of logits, \[\begin{align} \hat{\ell}^{LC}_Q(x_{<t}) &= \ell_P(x_{<t}) + \alpha \cdot [\ell_q(x_{<t}) - \ell_p(x_{<t})], \label{eq:dd95logits} \end{align}\tag{1}\] while the second adjustment is rank based, \[\begin{align} \hat{\ell}^{R}_Q(x_{<t}) &= \ell_P(x_{<t}) - \mathbb{1}_{\operatorname{rank}(\ell_p(x_{<t}) - \ell_q(x_{<t})) \leq k} \cdot \infty. \label{eq:dd95logits95rank} \end{align}\tag{2}\]

Samples can then be drawn using standard decoding methods [29], [30] from the approximation, \[\begin{align} \widehat{Q}(x_t \mid x_{<t}) &= \operatorname{softmax}(\hat{\ell}_Q(x_{<t})). \label{eq:dd95samples} \end{align}\tag{3}\]

3.2 Theoretical motivation↩︎

Our method is theoretically motivated by the Product of Experts [9] and Importance Sampling [10] literature. In Appendix 8, we show that the approximation \(\widehat{Q}\) can be formulated as a Product of Experts model, \[\widehat{Q}(x_t \mid x_{<t}) \propto \underbrace{\vphantom{\Bigg(\frac{a}{b}\Bigg)^{0.3}}P(x_t \mid x_{<t})}_\text{Base Expert} \cdot \underbrace{\Bigg[\frac{q(x_t \mid x_{<t})}{p(x_t \mid x_{<t})}\Bigg]^\alpha}_\text{Domain Expert},\] where \(\widehat{Q}\) is the product of a “Base Expert” \(P\), which provides the Target model’s general capabilities, and a “Domain Expert” given by the ratio between the two auxiliaries \(p\) and \(q\). Intuitively, the role of the domain expert can be summarized by three cases:

1. \(q(x_t \mid x_{<t}) \approx p(x_t \mid x_{<t})\): The token is similarly likely under both auxiliaries, so the domain-expert ratio is close to 1 and the probabilities from the base model \(P\) are largely unchanged.

2. \(q(x_t \mid x_{<t}) \gg p(x_t \mid x_{<t})\): The token is much more likely under \(q\) than \(p\), so the domain expert upweights the token.

3. \(q(x_t \mid x_{<t}) \ll p(x_t \mid x_{<t})\): The token is much less likely under \(q\) than \(p\), so the domain expert downweights the token.

Finally, DD can also be linked to importance sampling in Monte Carlo analysis, where the expectation of a function \(f(x)\) under a target distribution is estimated using samples drawn from a proposal distribution. Formally, \[\mathbb{E}_{x \sim D_{\text{target}}}[f(x)] = \mathbb{E}_{x \sim D_{\text{proposal}}} \bigg[ f(x) \frac{D_{\text{target}}(x)}{D_{\text{proposal}}(x)} \bigg],\] where the importance weight \(w(x) = D_{\text{target}}(x) / D_{\text{proposal}}(x)\) adjusts the expectation taken over the proposal distribution for differences between the proposal and target distributions. Analogously, Divergence Decoding uses the token-level ratio \(q(x_t \mid x_{<t}) / p(x_t \mid x_{<t})\) to adjust samples from the accessible Target model \(P\) toward the behavior of the inaccessible Retrain model \(Q\).

3.3 Model Distillation↩︎

For situations where we do not want to run three models in parallel online, we want to transfer the behavior of Divergence Decoding back into a single model’s weights. We treat a frozen Linear DD system as the teacher and fine-tune the Target model as a student using standard teacher–student distillation [31], [32] on the forget set. Training is performed using only a KL-divergence objective between the student model’s output and the frozen Linear DD teacher \(\widehat{Q}\): \[\mathcal{L}_{\text{unlearn}} = T^2 \cdot \mathrm{KL}\!\left( \sigma\!\left(\frac{\ell_P}{T}\right) \,\Big\|\, \sigma\!\left(\frac{\hat{\ell}^{LC}_Q}{T}\right) \right),\] where \(T\) is a temperature hyperparameter and \(\sigma\) denotes the softmax function. Conceptually, this procedure distills the unlearning signal encoded by the auxiliary models \(p\) and \(q\) into the weights of the Target model, converting an inference-time controller into a single parametric network.

4 Experiments and Analysis↩︎

We evaluate the effectiveness of DD using the two gold-standard unlearning benchmarks: MUSE [28] and TOFU [33]. All evaluations are performed using the Open Unlearning framework [34]. These benchmarks simulate an unlearning scenario whereby a model must eliminate specific knowledge (based on the ‘forget’ set) while preserving other capabilities (the ‘retain’ set).

A key difference between them is that TOFU uses instruction-tuned models to answer complex queries, and OpenUnlearning further expands this setup by penalizing incoherent generation on forget questions. In contrast, MUSE employs pre-trained models evaluated via few-shot Q&A on significantly simpler questions. The general sensitivity of instruction-tuned models to fine-tuning suggests that as a benchmark, TOFU is potentially harder than MUSE [35]–[37].

4.1 Setup↩︎

For MUSE [28], [38], we use the news dataset and fine-tune princeton-nlp/Sheared-LLaMA-1.3B [39] for our auxiliary models. Here, \(p\) is fine-tuned only on the provided forget set, while \(q\) is fine-tuned on the provided retain set. For TOFU [33], we use the official Open-Unlearning target and retrain 1B models as our auxiliary models (Table 4). \(p\) is trained on both the forget and retain sets, while \(q\) is trained only on the retain set. This differs from the MUSE configuration because the TOFU retain set is roughly nine times larger than the forget set. Training \(p\) only on the forget set would therefore cause \(p\) and \(q\) to undergo very different fine-tuning shifts, making the contrast between them reflect dataset size and fine-tuning dynamics rather than the effect of removing the forget set.

To assess the trade-off between utility and forgetting across hyper-parameter choices, algorithm variants, and model sizes, we employ distinct metrics suited to each benchmark’s complexity. For MUSE, we report the Euclidean distance to the Retrain baseline, normalized such that the Target model represents 100%. This provides an all-encompassing score capturing both Q&A and memorization performance. For TOFU, we utilize the aggregate score (with and without privacy), as detailed in Appendix F of [34].

4.2 Primary Result↩︎

Figures 1 and 2 present the core result of the paper. Divergence Decoding substantially outperforms prior methods on TOFU, marginally improves over the strongest baselines on MUSE Knowledge Memorization, and is less effective on MUSE Verbatim Memorization. This pattern roughly follows task complexity: TOFU uses instruction-tuned models to answer longer, more complex queries; MUSE Knowledge Memorization relies on shorter few-shot questions; and MUSE Verbatim Memorization is lifted directly from the training text, where simpler filtering or classification-style methods can be especially strong. We hypothesize that a key advantage of Divergence Decoding is that it leverages the semantic and reasoning capabilities of the auxiliary models, which becomes most useful when forgetting requires more than suppressing near-verbatim strings.

4.3 Algorithm and Hyper-Parameter Choice↩︎

Figure 3 studies Linear DD and Rank DD on both benchmarks across a wide sweep of hyper-parameters. On MUSE, we find that Rank DD outperforms on memorization while Linear DD marginally outperforms on Q&A. On TOFU, Rank DD marginally outperforms Linear DD. We find that there is a large range of hyper-parameter values that work well for both. Additional data in Figure 11 and Table 7.

4.4 Model Size↩︎

Given that our method works well with the 1B and 1.3B small models, a natural question is how sensitive performance is to the size of \(p\) and \(q\). We investigate this using the 2.7B Sheared-LLaMA model variant for MUSE, the Llama 3.2 3B variants for TOFU models, and trigram LMs based on Stupid Backoff [40] for both. Our trigram implementation pre-computes all scores as arrays the size of the vocabulary, effectively giving zero inference overhead and serving as a limiting case of “0% of \(P\)’s size.”

We evaluate the most optimal configuration for each model size. On MUSE, scaling from 1.3B to 2.7B yields a noticeably larger gain than the corresponding jump from 1B to 3B on TOFU. Meanwhile, the trigram models—which perform surprisingly well on some MUSE settings—fail almost entirely on TOFU. Upon further inspection of the Q&A questions on MUSE where the Trigram models perform well, we find that this is largely due to questions which are more similar to the underlying training data. Thus, we conclude that the Trigram models are likely most useful for unlearning verbatim content.

4.5 Privacy, Over-Unlearning, and Calibration↩︎

The naive implementation of the rank based method—e.g., setting targeted logits to \(-\infty\)—would produce degenerate privacy scores, since the losses would be infinite. To preserve the ability to evaluate over- versus under-unlearning in the rank-based setting, we instead replace the \(k\) most divergent logits with the \(k\)th largest logit in the unmodified distribution. Across both MUSE and TOFU, a broad range of hyper-parameters produce models that are statistically indistinguishable from a full retrain, striking a clean balance between over- and under-unlearning. The fact that the optimal region occurs around \(\alpha>1\) aligns with the intuition from §3.1 that a simple linear combination of logits may be a near-optimal solution.

Over-unlearning, even when utility is preserved, is not always optimal. In settings like toxic content prevention, aggressively suppressing certain outputs is reasonable. However, many real-world applications are highly sensitive to over-unlearning. For instance, in financial modeling—such as backtesting trading strategies or stress testing banks—the goal is to evaluate performance using only the information that would have been available at the time. For example, one would want to unlearn the 2008 financial crisis so they could realistically assess the performance of an LLM making decisions at the time. Over-unlearning would cause the model to overcompensate to the point that it assigns even lower likelihoods to events than what was expected at the time (e.g., if the true expectation at the time of a recession were 20% an over-unlearned model would assign less than that.)

4.6 Distillation↩︎

Firstly, we study the effect of the distillation on the model to understand what layers it targets. We froze the target model and computed the DD distillation loss (output KL), then backpropagated without updating weights. We measured the \(L_2\) norm of gradients on the MLP and attention weights at each layer. As shown in Figure 6, we find that the gradient propagates throughout the network and peaks in intermediate layers where prior work suggests factual associations are often stored [41], and the distill is not simply a bandaid on the final layers of the model.

Across benchmarks, the distilled model substantially outperforms prior gradient-based approaches, recovering most of the improvement achieved by Linear DD. Figure 7 demonstrates a smooth surface across the temperature and learning rates grid for TOFU. We also present Figure 13 in the appendix, though we find the surface to be less smooth and it is harder to find a global optimum.

4.7 Cross Tokenizer↩︎

We test whether DD depends on auxiliaries from the same family. To address this, we evaluated allenai/OLMo-2-0425-1B(-Instruct), google/gemma-3-1b-(pt/it), and Qwen/Qwen3-1.7B(-Base). We implemented a simple cross-tokenizer bridge. At initialization, each auxiliary token is decoded to text and re-encoded with the main tokenizer to find exact matches; if no exact match exists, we progressively shorten prefixes until a match is found. For example, if the auxiliary has “abcd” and the main model contains “abcd”, “abcde”, and “abcdef”, we map the auxiliary token’s logit difference onto all compatible main-model tokens. This mapping is built once and then applied at inference with a single vectorized scatter, so the additional overhead is negligible. In addition, we are careful when handling system prompts and special tokens.

As shown in Figure 16 and Table 6, we find that these cross-family auxiliaries remain close to the same-family baseline and still competitive with the broader set of unlearning methods.

4.8 Adversarial Prompting↩︎

A natural concern is whether the apparent unlearning is robust to prompt variation and repeated sampling under probabilistic decoding. To evaluate this, we apply the Leak@K benchmark [42] on TOFU, which measures whether forgotten information can be recovered across multiple generation attempts. Figure 17 shows that Distill DD matches the Retrain model, while Linear DD and Rank DD also remain competitive. These results suggest that Distill DD does more than apply a brittle surface-level correction: the forgotten information remains difficult to recover even under repeated adversarial prompting.

4.9 Sustainability and Scaling↩︎

Finally, prior work has found that many unlearning methods exhibit poor scalability—the unlearning of very large amounts of content—and sustainability—sequential requests to unlearn additional content. We explore the efficacy of our method along these dimensions using the MUSE scaling and sustainability benchmarks to ensure that performance does not degrade. To extend the benchmark, we use our aggregate score which includes performance on the original forget set (Q&A), ensuring that larger and subsequent forget requests do not come at the cost of the forget weights being overwritten. We also evaluate sequential distillation to ensure it does not result in catastrophic forgetting. As demonstrated by Figure 12, both the inference-time and distill DD perform well, with all methods except GradDiff within the margin of error of eachother.

4.10 Cost and Latency Analysis↩︎

A key consideration of applying our method is the increased inference-time compute from running the two small models in tandem with the large model. Denote the number of parameters in the large model as \(N\) and \(n\) the number in each small model. Following the approximation of [43], the total inference cost increases from \(2N \longrightarrow 2(N+2n)\), with the relative increase given by \(2n/N\). In Figure 8, we empirically measure the increase in compute costs associated with running over 1,200 different combinations of models in a distributed setting within a single 8x\(\{H100|B200\}\) instance (see Appendix 9 for details). We find that the compute costs tend to scale closely with our theoretical approximation. In Appendix 9, we examine the effect of our method on latency and find that the increase is generally less than 0.1%.

5 Beyond Text↩︎

One benefit of our method is its generality, i.e., it can be applied to any setting where samples are drawn from some distribution \(P\) and data exists to estimate \(p\) and \(q\). Along these lines, we explore the extent to which our method is effective in domains beyond text by applying it to image generation.

We begin with the setup of [11] and augment the sampling in latent space per equations 1 and 2 . The models \(p\) and \(q\) are estimated using data from the train split of ImageNet associated with the dog synset. Specifically, half the descendants from the dog synset are randomly assigned to the forget set \(F\) and the other half to the retain set \(R\)—notably, this random assignment ensures that any preferences over dog classes will be uncorrelated with the assignment to retain versus forget. The class-conditional ImageNet checkpoint from [11] is then fine-tuned on \(F\) and \(R\) to estimate \(p\) and \(q\), respectively. We then sample images from the model configured without any divergence decoding (Baseline) and with various linear and rank-based DD configurations. (Figure 9 and Appendix 11).

As a first quantitative evaluation of the efficacy of our method, we evaluate the content of class conditional generations using VQAScore [44]. For each class conditional generated image, we prompt a multi-modal LLM (MLLM) to assess whether the image contains the specific class and take the probability of “Yes” as the VQAScore—we rely on GPT-4o-mini for this task as it requires access to the log probabilities and many modern closed models do not provide this, e.g., GPT-5-nano. Table 1 presents mean VQAScores for class conditional samples split by whether the class was assigned to the retain or forget set. For linear divergence decoding setups, modest settings of alpha display efficacy, e.g., \(\alpha=1\) decreases the mean VQAScore on classes in the forget set from 97% to 20%. This is similar to our findings within the text domain where \(\alpha\) in the range of 1 to 2 typically yielded the best results. In contrast, the rank-based setups require larger values for top-k to reach similar efficacy, e.g., \(topk=250\).

As a second evaluation of the efficacy of our method, we evaluate the perceptual quality of generated images. Notably, a naive unlearning method could simply output noise for classes in the forget set. While this would constitute “unlearning,” it may not be particularly useful if the desired outcome is perceptually similar and plausible generations without the indicia associated with the classes to be forgotten, e.g., the identifiable style attributable to an artist requesting that a model provider adhere to copyright laws. Along these lines, we follow [45] and employ an MLLM-as-a-judge to perform pairwise comparison of the visual quality between samples from our baseline setup and a given divergence decoding setup.

Tables 2 and 8 present the performance for a variety of divergence decoding setups. In general, there is little decrease in the perceptual quality on samples conditional on classes in the retain set. For those in the forget set, however, there is a decrease in quality. For example, a setup with \(\alpha=5\) decreases the rate at which a generated image contains the class to be forgotten from 97% to 1%, but these images are also only preferred over baseline generations 31% of the time. As such, in practice one would have to sample, on average, two generations to get a sample which both does not contain the class to be forgotten and meets or exceeds the baseline quality.

6 Is Steering Sufficient?↩︎

While traditional unlearning has often focused on modifying a model’s parameters—and indeed ablations involving distillation indicate this is effective—our main results involving DD suggest that this need not be the case. Specifically, the MUSE and TOFU results suggest that in many practical use cases modifying the model weights is not only unnecessary, it is comparatively harmful to model utility:

Compliance with “Right to be forgotten" and addressing copyright violations. These requests are numerous and ad hoc which poses a challenge for traditional unlearning methods as highlighted in Figure 12. In a similar way, there are numerous examples of alleged copyright infringement by model providers. Our method, specifically the n-gram based setup, excel at eliminating verbatim memorization tasks (see Figure 4) with virtually no cost. We envision a scenario where our method can be used to quickly eliminate such violations, particularly the most egregious cases where copyrighted material is regurgitated verbatim.

Guardrails on API locked models For example, intentionally training \(p\) on a large amount of toxic content and \(q\) on the same data distribution as \(P\) could be used to approximate a \(\hat{Q}\) with reduced toxic content generation. As we discuss in Section 4.10 and Appendix 9, in production-like environments compute costs tend to scale close to theoretical approximation, and there is virtually no increase in latency.

Low-Volume Deployments (e.g., Financial Backtesting) As detailed in Appendix 9.3, there is a computational trade-off between inference-time steering and distilling a final model. While distillation reduces inference latency, it incurs a heavy upfront training cost. If the total expected inference volume (\(I\)) is low—such as in one-off backtesting runs or targeted analysis—it is more FLOP-efficient to simply steer the model using Divergence Decoding rather than investing compute to distill a standalone unlearned model.

7 Conclusion↩︎

Traditional approaches to machine unlearning have treated the problem as one of “forced forgetting"—modifying a large model’s weights directly, often at the cost of model utility. Our findings present an alternative to this paradigm by demonstrating that unlearning can be effectively solved through steering the generation of a target model based on the difference between two auxiliary models. By training small auxiliary models to learn specific distributions (forget and retain sets), we achieve precise control over model outputs that surpasses current state-of-the-art (SOTA) benchmarks. Further, distilling a frozen divergence-decoding setup into a single set of model weights yields a model checkpoint that can be served without any latency consequences. This method, validated across both text and image domains, suggests that the path to safer, compliant AI lies not in crippling the base model, but in guiding it. As legal and privacy requirements for LLMs continue to tighten, our”learning over forgetting" approach provides a practical path forward that redefines SOTA performance for high-stakes deployments.

Acknowledgments↩︎

We acknowledge generous financial support from the Booth School of Business and the Center for Applied AI. This research was supported in part by the Pythia computing cluster at The University of Chicago Booth School of Business which is funded by the Office of the Dean.

We thank Ralph Koijen, Sanjog Misra, and Ted Sumers for helpful discussions. An earlier version and subset of the analyses in this paper [46] appeared in the NeurIPS 2025 Workshop: Generative AI in Finance. We thank the reviewers and session participants for valuable feedback.

Conflict of Interest Disclosure↩︎

The authors have no competing interests to disclose.

Impact Statement↩︎

In general, we intend unlearning to support beneficial use cases - for debiasing models, preventing toxic and copyrighted content generation, and legitimate research in other domains such as finance. However, we acknowledge the approach could be misused to induce undesirable or harmful biases.

8 Connection to Product of Experts↩︎

[9] introduced the Product of Experts (PoE) framework whereby \(n\) probability models are multiplicatively combined into a single model. Let the \(i\)-th expert be denoted by \(f_i(x|\theta_i)\), then a PoE model \(R\) comprised of \(n\) experts is given by, \[\begin{align} R(x|\theta_1, ..., \theta_n) &= \frac{1}{Z}\prod_{i=1}^n f_i(x|\theta_i), \end{align}\] where \(Z\) is a normalization constant. To highlight the connection between divergence decoding and PoE, recall Eq. 1 : \[\hat{l}_Q(x_{<t}) = l_P(x_{<t}) + \alpha \cdot [l_q(x_{<t}) - l_p(x_{<t})].\] In Eq. 1 , a given model \(M\) has logits which are equal to the log-probabilities up to an additive constant which depends on the token sequence prefix \(x_{<t}\) but not the token \(x_t\), i.e., \[l_M(x_{<t}) = \log M(x_t|x_{<t}) + C_M(x_{<t}). \label{eq:app95logits95log95probs}\tag{4}\] Substituting Eq. 4 into Eq. 1 for each model, gathering the constants, and performing some algebra reveals the link to PoE: \[\begin{align} \log\widehat{Q}(x_t|x_{<t}) &= \log P(x_t|x_{<t}) + \alpha \cdot [\log q(x_t|x_{<t}) - \log p(x_t|x_{<t})] + C \\ \widehat{Q}(x_t|x_{<t}) &\propto \exp\big( \log P(x_t|x_{<t}) + \alpha \cdot [\log q(x_t|x_{<t}) - \log p(x_t|x_{<t})] \big) \\ &\propto P(x_t|x_{<t}) \cdot q(x_t|x_{<t})^\alpha \cdot p(x_t|x_{<t})] ^{-\alpha} \\ &\propto P(x_t|x_{<t}) \cdot \Bigg[\frac{q(x_t|x_{<t})}{p(x_t|x_{<t})}\Bigg]^\alpha. \end{align}\]

9 Detailed Analysis of Compute and Runtime Costs↩︎

In this section we explore the compute and runtime costs associated with our method using theoretical and empirical analyses. Additionally, we compare these costs to those associated with other unlearning methods to provide guidance on when our method is desirable. In general, we find that our method introduces minimal latency (less than 0.1% increases in realistic production environments) and compares favorably to other unlearning methods for a wide range of compute budgets.

9.1 Compute Requirements↩︎

As presented in Section 4.10, the compute increase associated with our method can be approximated as \(2n/N\) where \(n\) and \(N\) are the number of parameters in the small and big models, respectively. For example, applying our method to a 10B parameter model using 1B parameter small models is expected to require a 20% increase in compute. While this is a useful theoretical approximation, we empirically explore this approximation using a distributed setup on 8xH100 and 8xB200 instances using more than 1,200 unique combinations of models for \(P\), \(p\), and \(q\).

For our specific setup, we target an environment where the small models \(p\) and \(q\) are running on some number of accelerators while multiple copies of the large model \(P\) is running on additional accelerators. We consider the set of candidate models for \(P\), \(p\), and \(q\) as those listed in Table A9 of [3] and add several models in the range of 19-70B parameters following the Llama 3 architecture [4]. Additionally, we consider four vocabulary sizes for each model: \(2^{15}\), \(2^{16}\), \(2^{17}\), and \(2^{18}\).

We then match models for \(p\) and \(q\) to \(P\) such that \(2n \leq N\) and only consider models for \(P\) where \(N > 8e9\). The compute increase required to run a given combination of models is then measured as the ratio \((t_P + t_p + t_q)/t_P\) where \(t\) is the time required to run the models measured in GPU-hrs. Results for all combinations of models, vocabulary sizes, and devices are presented in Figure 8. In general, we find a strong agreement with the theoretical approximation.

9.2 Latency↩︎

An additional consideration of applying our method is latency, i.e., many applications require fast responses to users and the an increase in latency of 10-20% could be unacceptable. Following from Section 9.1 above, we explore the latency impact of our method in a distributed environment where the small models \(p\) and \(q\) can be run in parallel with multiple copies of \(P\). In this setting, the primary contributor to latency is the time required to sync the logits in Eq. 1 across devices such that sampling from the approximation to \(Q\) can be performed.

Along these lines, we measure the increase in runtime as the ratio \(t_{Q}/t_P\) where the time \(t\) is the total time required to generate a sequence of fixed length, \(t_Q\) is the time to do this under the distributed divergence decoding setup, and \(t_P\) is the time to do this under a setup where \(P\) is run on a single GPU with no synchronization overhead. The two key factors here are the vocabulary size which determines the size of the data being synchronized across GPUs and the size \(N\) of \(P\) which determines the baseline runtime required. Figure 10 shows that for most model configurations, the increase in runtime is less than 0.1%. For smaller “large” models, i.e., \(N < 20e9\), and the largest vocabulary size, the increase is in runtime is roughly 0.2-0.5%. Thus, while there is undeniably an increase in latency, it is relatively modest at \(<0.5\%\) for the vast majority of realistic model configurations.

9.3 Cost of Steering vs Distilling↩︎

We compare the computational cost of using Divergence Decoding (DD) directly at inference time versus using DD to distill a single unlearned model. Let \(d_{retain}\) and \(d_{forget}\) be the dataset sizes (in tokens), \(N\) and \(n\) be the parameters of the large and small models, and \(e_N\) and \(e_n\) be the number of training epochs. Since both methods require training the auxiliary models (the "teacher"), that cost appears on both sides of the inequality. Therefore, steering becomes more costly than distilling only when the extra inference compute of the auxiliary models exceeds the cost of training the student model. Assuming the student is trained on the forget set, this occurs when:

\[\begin{align} \underbrace{6 n e_n(d_{\text{retain}} + d_{\text{forget}})}_{\text{Train Aux}} + \underbrace{2(N+2n)I}_{\text{Steering Inf.}} &\geq \underbrace{6 n e_n(d_{\text{retain}} + d_{\text{forget}})}_{\text{Train Aux}} + \underbrace{\left(6N + 4n\right)e_N d_{\text{forget}}}_{\text{Distill Train}} + \underbrace{2NI}_{\text{Student Inf.}} \\ 2(N+2n)I &\geq (6N+4n)e_N d_{\text{forget}} + 2NI \\ 2NI + 4nI &\geq (6N+4n)e_N d_{\text{forget}} + 2NI \\ 4nI &\geq (6N+4n)e_N d_{\text{forget}} \\ I &\geq \frac{(6N+4n)e_N d_{\text{forget}}}{4n} \\ I &\geq \frac{3Ne_Nd_{\text{forget}}}{2n} + e_Nd_{\text{forget}} . \end{align}\]

10 Detailed Experimental Setups↩︎

10.1 MUSE↩︎

We finetune the LlaMA models using the AdamW Torch optimizer and a cosine scheduler for 10 epochs. We set the learning rate such that the loss approximately halves over the course of training. We swept the LLaMA models with \(\alpha \in \{0.5, 0.6,\dots, 1.5\}\) and \(\text{top-}k \in \{1, 5, 20, 50, 100, 200, 500, 1000\}\) and the trigram models at \(\alpha \in \{5, 10,\dots30\}\) and \(\text{top-}k \in \{1, 2, 3, 5, 10\}\).

For the other methods, we use the default settings provided by OpenUnlearning.

10.2 TOFU↩︎

For \(p\) and \(q\) we use open-unlearning/tofu_Llama-3.2-1B-Instruct_full, open-unlearning/tofu_Llama-3.2-1B-Instruct_retain90, and the counterparts for 3B. For finetuning and distillation based methods, we grid search learning rates \(\{5\times10^{-7}, 8\times10^{-7}, 1\times10^{-6}, 2\times10^{-6}, 3\times10^{-6}, 4\times10^{-6}, 5\times10^{-6}, 1\times10^{-5}\}\) and epochs from 1 to 10. For other methods, such as WHP, GUARD, and ECO, we grid sweep relevant hyper-parameters within a reasonable range.

11 Application to Image Generation↩︎

In this section we detail the experimental setup used to assess the quality of generated images and additionally present (i) distributional statistics of image quality generated using our divergence decoding setup and (ii) a random sample of generated images for qualitative analysis.

11.1 Experimental Setup↩︎

Each image in our sample is generated using class conditional generation using the default generation parameters of [11] for their ImageNet checkpoint. We fine-tune the parameters of auto-regressive transformer in this model to arrive at checkpoints for \(p\) and \(q\) using a peak learning rate of 10% of that used in [11] training for 10 epochs each over the retain and forget sets. We then generate image samples following Eq. 3 where the adjustment from \(p\) and \(q\) is based solely on the output from the auto-regressive transformer.

11.2 Measuring Image Content and Quality↩︎

Image content is measured using VQAScore [44]. This approach requires access to the log probabilities of the multi-modal LLM (MLLM) used to assess quality, therefore these assessments rely on the GPT-4o-mini rather than newer models such as GPT-5-nano for which the log probabilities are not exposed. When measuring perceptual quality, we use a MLLM-as-a-judge in a pairwise comparison configuration [45]. Since this setup does not require access to the log probabilities, we leverage several state of the art small MLLMs for this task: Gemini 2.5 Flash-Lite, GPT-5-nano, and Qwen3-VL 8B.

11.3 Distributional Properties of Generated Images↩︎

Ideally, samples from the model would no longer exhibit image semantics associated with the data in the forget set \(F\), while retaining high perceptual quality relative to the retain set \(R\). Following prior work [48], we measure the quality of the generated images using the Fréchet Inception Distance (FID).

We assess performance by computing the FID between three pairs of data: (i) baseline images from the retain set and generated images using classes from the retain set (FID(\(B_R\),\(G_R\))), (ii) baseline images from the forget set and generated images using classes from the forget set (FID(\(B_F\),\(G_F\))), and (iii) baseline images from the retain set and generated images using classes from the forget set (FID(\(B_R\),\(G_F\))).

Efficacy in this setting preserves perceptual quality relative to the retain set, i.e., low FID(\(B_R\),\(G_R\)) and low FID(\(B_R\),\(G_F\)), while increasing the distance between the forget set and images generated based on those classes, i.e., high FID(\(B_F\),\(G_F\)). In Table 9, we present FID statistics for a variety of decoding setups. For the linear setup, an \(\alpha=1\) seems to work well, e.g., a roughly 33% increase in FID(\(B_F\),\(G_F\)) with only a 5% increase in FID(\(B_R\),\(G_R\)) relative to the baseline. In contrast, the topk based methods appear to require much larger values of \(k\) to be effective.

11.4 Image Generation Samples↩︎

References↩︎