Training That Keeps Its Own Books: A Per-Creator Update Ledger for Opt-Out and Royalties

When a model is trained on work from many creators, three things are usually done in separate stages. The model is trained. Later, someone computes which creators influenced a given output, in order to credit or pay them. Later still, if a creator withdraws consent, someone runs a separate "unlearning" procedure to remove their influence. Each later stage re-reads the data or re-derives gradients that the original training run already computed and then threw away.

This note proposes a different design. During training, the optimizer records, for each creator, exactly how much of the model's total parameter change came from that creator's data. The result is a ledger: a per-creator account of the model's parameter movement that sums exactly to the full training displacement. The ledger then serves two purposes. It gives first-order attribution scores for any output. When a creator opts out, it supplies a subtraction that removes that creator's direct contribution, followed by a short repair phase.

The design lesson comes from one-pot chemistry. There, the waste of multi-step synthesis is avoided by not isolating intermediates, and by designing reagents whose byproduct from one step activates the next. The clearest example is the imidazole released during photoredox fluoroalkylation, which then serves as the base that activates the borylation (Integrated redox-active reagents for photoinduced regio- and stereoselective fluorocarboborylation). In training, the analogous byproduct is the per-microbatch gradient. It is computed anyway during gradient accumulation and discarded immediately. We propose to keep it, split by creator.

Core Claim

For training with a parameter-efficient adapter (a small set of added trainable weights, so that per-creator copies fit in memory), an Adam-style optimizer's update can be split exactly across creators, step by step. The split works because two things hold at each step. Momentum is a linear sum of gradients. The per-coordinate preconditioner is shared by all creators.

Let $g_{s,c}$ be the gradient from creator $c$'s microbatches at step $s$. Define creator $c$'s momentum share as $m_{t,c}=\beta m_{t-1,c}+(1-\beta)g_{t,c}$. Let $D_t$ be Adam's diagonal preconditioner, $\eta_t$ the learning rate, and $\lambda$ the weight decay. The ledger entry is then

$$\Delta_c=\sum_{t=1}^{T}\Big(\prod_{s>t}(1-\eta_s\lambda)\Big)\,\eta_t D_t^{-1} m_{t,c},\qquad \theta_T-\theta_0=-\sum_c \Delta_c .$$

The identity holds exactly, not approximately, because every operation in the chain is linear once $D_t$ is fixed. It is the parameter-space counterpart of the Additivity Lemma of Computational Copyright, which splits a sequence's influence across its tokens. Here the model's total movement is split across its creators.

From the ledger, the direct effect of creator $c$ on the log-likelihood of an output $y$ is approximately $\nabla_\theta \log p(y\mid\theta_T)^\top\Delta_c$. This is a first-order Taylor term that gives a royalty score from a single backward pass per output.

For an opt-out, we set $\theta\leftarrow\theta_T+\Delta_c$ and then run a short equilibration phase: brief fine-tuning on retained data only. The name borrows from the acid-heating step that converts the 7-epi byproduct into the stable natural isomer in Bioinspired Total Synthesis of (+)-Kopsiyunnanine B. The equilibration updates are themselves recorded in the ledger, so the ledger remains exact after each opt-out. Sequential opt-outs therefore compose.

The claim to be tested has three parts. The subtraction-plus-equilibration model should sit closer to a model retrained without the creator than post-hoc unlearning methods do, at a small fraction of retraining cost. Ledger attribution should track leave-one-creator-out retraining better than post-hoc gradient attribution computed only at the final checkpoint. Both should hold on text and on symbolic music.

The known weakness is stated up front. Subtraction removes only the direct first-order contribution. Indirect effects, where creator $c$ changed the trajectory that other creators' gradients were computed along, remain. Whether equilibration cleans these up is the central empirical question.

Relation to Prior Work

The closest pipeline work evaluates the stages this proposal fuses. Watershed watermarks owners' data, fine-tunes Llama-8B, audits, and then checks whether post-hoc unlearning really removed a watermarked owner. It finds that unlearned models often retain detectable watermark traces. Watershed motivates this proposal and supplies its sharpest test, but it contributes no training-time mechanism of its own.

WASA couples training with attribution. It teaches the model to emit invisible provider-ID tags. It needs a separate training stage, it has no route to withdrawal, and its accuracy degrades as the number of providers grows.

Unlearning work supplies our strongest competitors. Opt-Out removes entities with negative preference optimization regularized by a Sliced Wasserstein term. ReTrack redirects diffusion trajectories toward retained neighbors. Machine Unlearning for Streaming Forgetting handles sequential deletion requests for classifiers. All three operate after training and must infer what the creator contributed, while the ledger has that contribution on record.

On attribution, Computational Copyright shows two things: perceptual similarity is nearly uncorrelated with causal influence, and gradient attribution with LoGra reaches a positive correlation with leave-one-out retraining. DATE-LM complicates the picture. BM25 often beats gradient methods, but lexical methods fail under counterfactual entity swaps. That result constrains us: we must include BM25 and test on the counterfactual setting where lexical overlap is uninformative.

The name "one-pot" has also been used in One-Pot Multi-Frame Denoising for mutual supervision among burst frames. That work shares the vocabulary but addresses nothing about ownership.

Research Program

We will build a drop-in optimizer wrapper for adapter fine-tuning. It works as follows. Each training batch is assembled from creator-homogeneous microbatches, meaning each microbatch contains data from a single creator. Gradients are accumulated per microbatch as usual, but are also added into per-creator momentum shares. Per-step preconditioners are shared across creators. Weight decay is applied to the ledger as well as to the parameters.

Memory scales as the number of creators times the adapter size. For 20 bloggers and a low-rank adapter on an 8B model, this is a few gigabytes. Compute overhead should be small because per-microbatch gradients already exist during accumulation.

For settings with many more creators, we will test a projected ledger. In this variant, the $\Delta_c$ are stored after a fixed random low-rank projection, as in LoGra. Attribution is computed in the projected space, and subtraction is replaced by a projected correction. The goal is to measure how much faithfulness is lost.

The analysis has three threads. The first measures how large the indirect, trajectory-mediated effect is relative to the direct term. We do this by comparing $\theta_T+\Delta_c$ with the retrained model across training lengths, expecting the gap to grow with the number of steps since the creator's data was seen. The second measures how many equilibration steps close that gap. The third measures whether the ledger stays accurate over a stream of sequential opt-outs, since each equilibration phase is itself logged.

Proposed Experiments

Text, main setting. We use Watershed's Blog Authorship Corpus (20 bloggers) and C4-realnewslike (10 institutions), with each author or institution treated as a creator. Following Watershed, each creator's data is watermarked with Waterfall and KGW. We fine-tune Llama-3.1-8B with a low-rank adapter.

Twenty leave-one-creator-out retrains are affordable at this scale, and they are the reference throughout. We measure three things after an opt-out:

  • Closeness to the retrained model: average KL divergence on held-out prompts.
  • Residual trace of the removed creator: watermark detection AUROC on that creator. Near 0.5 is the goal. Watershed reports 0.94 for Waterfall persisting after ordinary fine-tuning, which is the level we must drive down.
  • Utility: MMLU, ARC, and HellaSwag.

Compute is reported as a fraction of retraining cost.

Attribution. We compute the Spearman correlation between ledger scores and the true change in output log-likelihood under leave-one-creator-out retraining. We also run DATE-LM's counterfactual factual-attribution subset (ROME with entity swaps), with facts grouped into pseudo-creators, to check that the ledger does not fall into the lexical trap.

Music. On MAESTRO with a small symbolic transformer, leave-one-out is feasible, so ledger attribution can be compared directly with LoGra under the protocol of Computational Copyright. Here we also test whether the ledger finds its "high-attribution, low-similarity" tracks: pieces that sound unlike the output but whose removal still raises perplexity.

Streaming. We run five sequential opt-outs, tracking the gap to a model retrained without all removed creators after each one.

Baselines

The naive reference points are two. The first is the unmodified model, which sets the ceiling of residual trace and the utility reference. The second is plain gradient ascent on the departing creator's data, which is the cheapest post-hoc removal. Both run on identical adapters and data.

The gold reference is leave-one-creator-out retraining with the same seeds and schedule. Every other method is scored by its distance to this model, not by forgetting alone.

The strongest existing unlearning competitor is Opt-Out's NPO with Sliced Wasserstein regularization, run from the released code brightjade/Opt-Out. It is strongest because it explicitly protects neighboring knowledge while forgetting. On ELUDe with Llama-3.1-8B it reports Forget Quality 87.8% with utility 63.3% against an original 64.7% (Opt-Out). We give it the same number of gradient steps on retained data as our equilibration phase, and the same hyperparameter-search budget.

Beating Opt-Out means three things together. Our method must reach a lower KL to the retrained model than Opt-Out does. Its watermark AUROC on the removed creator must be at least as close to 0.5 as Opt-Out's. And its utility must stay within one point of Opt-Out's.

For attribution, the strongest method is LoGra computed post hoc at the final checkpoint with the same projection dimension as the projected ledger. On MAESTRO it reports a correlation of up to 0.410 with leave-one-out (Computational Copyright). We will reproduce it under our protocol rather than compare against that number across settings. BM25 serves as the lexical baseline; the file has no DATE-LM numbers for it (no reported result found on Lacuna for BM25 on DATE-LM counterfactual attribution). WASA serves as a watermark self-report baseline on the text setting.

Two ablations isolate the key ingredient. The first, equilibration only, runs the same retained-data fine-tune without the ledger subtraction. If it matches the full method, the ledger contributes nothing to unlearning. The second, final-checkpoint ledger, replaces the trajectory-accumulated $\Delta_c$ with a single gradient-times-preconditioner estimate computed after training. If it matches, recording during training is unnecessary.

Why not just…?

Why not just run post-hoc LoGra and post-hoc Opt-Out, which already exist? This is the main threat, and the two ablations above are built to settle it. The argument for the ledger is that post-hoc methods estimate a creator's contribution from the endpoint. They cannot see the creator's effect early in training, which later updates carried forward. Watershed's finding that unlearned models keep radioactive watermark traces suggests those estimates miss something. If the final-checkpoint ledger and Opt-Out match our KL-to-retrain and AUROC numbers, the contribution shrinks to a compute saving, and we will report it that way.

Why not just shard training by creator and retrain the affected shard? Sharding gives exact removal. The partitioned construction studied in GenAI Copyright Evidence with Operational Meaning is close in spirit. Sharding does not, however, produce attribution for the data that stays in. It also costs utility when shards are small, and with 20 creators each shard sees a twentieth of the data. We will include a 20-shard ensemble as an extra point on the utility-versus-exactness curve. If its utility loss is small, sharding is the better answer for few-creator settings, and the ledger's case rests on many-creator and royalty uses.

Why not just attribute with BM25 or perceptual similarity? Computational Copyright reports near-zero correlation between similarity metrics (MERT, CLAP) and causal influence in music. DATE-LM finds that lexical methods fail under counterfactual entity swaps. Still, BM25 wins DATE-LM's non-counterfactual tasks, so we run it on both regimes. We expect it to win where overlap tracks influence and to lose on counterfactual facts and on high-attribution, low-similarity music.

Why not just filter up front, as The Stack did? The Stack shows that license filtering, deduplication, and an opt-out search tool cost little in quality. Its 350M model reached 12.89% HumanEval pass@1, against 12.76% for CodeGen. But filtering only acts before training. It cannot honor a withdrawal after release, and it computes no credit for included creators, which is exactly the gap the ledger targets.

Decisive Checks

The idea fails if either of two things happens. The first is that "equilibration only" reaches the same KL to the retrained model and the same watermark AUROC as ledger subtraction plus equilibration. The second is that final-checkpoint attribution matches ledger attribution against leave-one-creator-out retraining. Either would show that the recorded trajectory adds nothing.

The idea succeeds if subtraction plus a short equilibration beats Opt-Out on distance to the retrained model and on residual watermark trace, at equal utility and much less than retraining cost, and if the ledger's attribution holds up on counterfactual facts where BM25 fails.