🤖 machine learning

The Steering Budget: Examples beat Knobs

This paper argues that the controllability of generative models is fundamentally limited by a "budget" inherent in their training data, demonstrating that while traditional "knob" methods (like prompts or guidance scales) can only access a fraction of this range, providing concrete examples allows models to reach the full spectrum of a property's potential, including targets that cannot be verbally specified.

Original authors: Raj Kumar Rajendran

Published 2026-07-17

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Raj Kumar Rajendran

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a super-smart robot artist that can draw anything you ask for, from a golden retriever to a crystal structure. For years, scientists have tried to control this robot by giving it "knobs" to turn. You might say, "Make it brighter," or "Make it look like a photo," or "Turn the guidance dial to the maximum." It's like trying to steer a ship by twisting a single rudder. But there's a frustrating limit: no matter how hard you twist the knob, the robot eventually stops moving. It hits a wall. You want the image to be really bright, but the robot only gets it "kind of" bright and then refuses to go further.

This paper asks a simple but revolutionary question: Why does the robot stop? Is it because the robot is broken, or is there a hidden rulebook it was given before it ever started drawing? The authors discovered that the robot isn't broken; it's just working within a strict "budget" set by the data it learned from. They found that there are two ways to talk to this robot: Telling and Showing. "Telling" is using the knobs and words to narrow down what you want. "Showing" is handing the robot a pile of examples and saying, "Make more stuff like these." The big surprise? "Showing" can reach places "Telling" can't even dream of, and we can calculate exactly how far each method can go before we even turn on the robot.

The Great Wall of "Telling" vs. The Magic of "Showing"

Think of the robot's knowledge like a giant library of books. Each book is a specific type of thing, like "Beach Scenes," "Snowy Mountains," or "Crystal Structures."

Telling (The Knob): When you use a knob, you are standing inside one specific section of the library, say the "Beach" section. You can ask the robot to make the beach sunnier or the sand whiter. But you are stuck in that one section. You can't magically turn a beach scene into a snowy mountain just by twisting a dial. You are limited to the variations that already exist inside the "Beach" section.
Showing (The Examples): When you show examples, you aren't stuck in one section. You can hand the robot a mix of books: some from the "Beach" section, some from the "Snow" section, and some from the "Desert" section. You say, "Make more stuff that looks like this mix." Suddenly, the robot isn't just tweaking one thing; it's exploring the whole library. It can combine the brightness of a beach with the texture of snow in a way a single knob never could.

The paper calls this the Budget. Before the robot is even trained, the data it learns from sets a hard limit on how much it can change.

The "Within-Bin" Budget (Telling's Reach): This is the room you have to wiggle inside a single category. If you want a beach to be brighter, the budget is how much brighter a beach can get based on the photos the robot has seen.
The "Between-Bin" Budget (Showing's Reach): This is the room you have to jump between categories. This is the difference between the average brightness of a beach and the average brightness of a coal mine. This gap is often huge—much bigger than the wiggle room inside a single category.

The authors found that for most things we want to control, the "Between-Bin" budget is the big one. It's the massive gap between different types of things. Knobs (Telling) can only reach the tiny wiggle room inside a category. Examples (Showing) can reach the massive gaps between categories.

The "Knob" Myth and the "Example" Reality

You might think, "If I just turn the knob harder, won't it work?" The paper says: No.
They tested this with two very different robots: one that draws images (like a digital artist) and one that designs crystal structures (like a materials scientist).

In the Crystal Lab: They tried to make crystals with a wider "band gap" (a specific energy property). The "knob" (a simple tag saying "high band gap") barely moved the needle. But when they showed the robot examples of crystals that actually had high band gaps, the robot's output jumped tens to hundreds of times further than the knob ever could.
In the Image Lab: They tried to make images look more "animal-like." A strong, learned knob could move the needle a little bit, but only if it accidentally started making images that looked like different animals entirely (breaking the rules of the "bin"). The "Showing" method, which picked the best animal categories to mix, moved the needle 3 times further than the best knob.

The paper explicitly rules out the idea that "better knobs" will solve this. They argue that the limit isn't a flaw in the robot's design; it's a fundamental law of the data. If the data doesn't have a big gap between categories, a knob might work fine (like making an image slightly brighter). But if the goal requires jumping between different types of things, a knob is structurally incapable of doing it.

Why This Matters: The "I Know It When I See It" Problem

Here is the coolest part. Sometimes, experts know what they want but can't explain it.
Imagine a film editor who watches a hundred takes of a scene and picks the best ten. They can't say why those ten are perfect. They just "know." If you ask them to describe the "vibe" to a robot, they might say, "Make it more emotional," but the robot will just make a generic sad face.

Telling fails here: You can't give the robot a word for a feeling you can't describe.
Showing wins here: You just hand the robot the ten clips you liked. You don't need to explain the "why." The robot looks at the mix of those ten clips and says, "Ah, I see the pattern. I'll make more of that."

The paper shows that "Showing" can reach these "unnameable" goals because it doesn't need to define the target with words. It just needs to show the pattern. It can even mix two opposite things at once—like "clean vehicles" and "clean food"—which a single knob usually fails to do, often just giving you a muddy, confused average of both.

The Verdict: Measure First, Then Choose

The paper doesn't just say "Examples are better." It gives you a recipe to know when to use them.
Before you even start generating, you can do a quick "audit" of your data. You can calculate the "Budget" to see how much of the change you want comes from inside a category (wiggle room) versus between categories (the big jumps).

If the "Between" budget is small: A knob is fine. You don't need to show examples.
If the "Between" budget is huge: You must show examples. A knob will never get you there.

The authors tested this on images and crystals, and the math held up perfectly. They even showed that if you try to "tune" a robot to be perfect at one thing (like making everything look "aesthetic"), you often lose all the variety and end up with a boring, repetitive robot. This is because tuning works one image at a time, shrinking the variety. "Showing," by mixing different categories, is the only way to keep that variety alive.

In short, the paper teaches us that to steer a generative AI, we shouldn't just twist the dials. We need to look at the map of the data first. If the destination is far away, we don't need a better steering wheel; we need to show the robot the map and let it choose the best path. And sometimes, the best path is one we can't even name, only show.

Technical Summary: The Steering Budget: Examples beat Knobs

Problem Statement

Generative models are typically steered using "knobs"—prompts, guidance scales, or property tags. However, practitioners observe a hard ceiling: pushing these controls to their limits often fails to move a target property (e.g., image brightness, crystal band gap) to the desired extent. The paper posits that this limitation is not a shortcoming of the model's architecture or training process, but a structural constraint set by the training data itself.

The core problem is distinguishing between two types of steering operations:

Telling: Describing a target via a prompt or tag (e.g., "bright dog"). This is a conjunctive operation that narrows the output distribution by intersecting constraints within a specific category.
Showing: Providing a set of examples and asking for "more like these." This is a disjunctive operation that unions diverse instances, allowing the model to capture targets that cannot be articulated in words or that require combining opposing properties.

The paper argues that the gap between what "telling" can achieve and what "showing" can achieve is not incidental but is a fixed budget determined by the variance structure of the training data before the model is even trained.

Methodology

Theoretical Framework: The Budget

The authors define a generative model's output space as being sorted into bins ( $B$ ) based on a "cheap" label $P$ (e.g., image class, crystal chemistry). An "expensive" property $L$ (e.g., aesthetic score, band gap) varies within and between these bins.

The total variance of $L$ in the training data ( $J$ ) is decomposed using the Law of Total Variance into two distinct budgets:

Within-Bin Budget ( $T$ ): The average variance of $L$ inside a single bin. This represents the room available for telling. Since telling operates by reweighting outputs within a fixed bin, it is structurally confined to this budget.
Between-Bin Budget ( $E$ ): The variance of the means of $L$ across different bins. This represents the room available for showing. Showing operates by changing the mixture of bins (the "recipe" $P$ ) from which the batch is drawn, allowing it to access this budget.

The total variance is exactly:
$\text{Var}_J(L) = \underbrace{\sum_b w_b v_b}_{T \text{ (Within)}} + \underbrace{\sum_b w_b (g_b - \bar{g})^2}_{E \text{ (Between)}}$
where $w_b$ is the bin share, $v_b$ is the within-bin variance, and $g_b$ is the bin mean.

The Reach of Operations

The paper derives that the maximum shift an operation can achieve in the mean of $L$ is bounded by $\sqrt{\chi^2} \times \text{Budget}$ , where $\chi^2$ measures the deviation from the original distribution.

Telling: Confined to $T$ . In practice, knobs (like guidance scales) realize a small $\chi^2$ (near 1), limiting their reach to roughly $T$ .
Showing: Accesses $E$ . By constructing a recipe that departs significantly from the data distribution, showing can realize a much larger $\chi^2$ (often $\sim 100$ ), allowing it to move the mean far beyond the reach of any knob.

Empirical Validation

The authors test these claims in two unrelated domains:

Images: A diffusion transformer (DiT) trained on ImageNet. Bins are ImageNet classes; targets include brightness, aesthetic scores, and CLIP content scores.
Crystals: A generator trained on a materials database (Alexandria). Bins are chemical compositions; targets include band gap, stability, and density.

They perform a "cheap audit" on the training data to compute $T$ and $E$ without generating any samples, then verify if real models adhere to these budgets.

Key Contributions

The Budget Distinction: A precise, quantitative account that splits a property's steerability into a "telling" part (within-bin) and a "showing" part (between-bin). This split is computable from training data alone, before model training.
The AND/OR Observation: A formalization that "telling" is conjunctive (intersection/narrowing) while "showing" is disjunctive (union/diversity). This explains why showing can reach targets involving "or" conditions or tacit preferences that cannot be named.
Unifying Lens on Failure Modes: The paper reframes four familiar generative modeling problems—mode collapse, the alignment tax, reward hacking, and failure of compositional generalization—as a single structural mismatch: attempting to solve a "showing" problem (requiring collection-level spread) using "telling" methods (per-output optimization).
Predictive Framework: The ability to predict a priori whether a target is reachable by knobs or requires examples. If the between-bin share ( $E/(E+T)$ ) is high, examples are necessary; if low, knobs suffice.
Recipe for Steering: A practical method for constructing the optimal "recipe" (bin mixture) to hit a target. For averaging goals, the recipe concentrates on the single best bin; for spread/coverage goals, it mixes bins to cover the Pareto front.

Results

1. The Split is Exact and Carries Over

Exactness: The decomposition of variance into $T$ and $E$ held exactly in both domains.
Carry-over: For properties the model reproduces faithfully (e.g., crystal density, image brightness), the budget calculated from the training data accurately predicted the model's behavior. For properties the model struggles to reproduce (e.g., crystal stability), the data audit was a poor predictor, necessitating a direct audit of model outputs.

2. Examples Beat Knobs (When the Budget Demands It)

Magnitude: In the crystal domain, where the between-bin share was high (e.g., 0.98 for band gap), choosing chemistries (showing) moved the target 6.8 times further than the strongest possible within-chemistry knob.
Knob Limits: Even when using the strongest possible knobs (e.g., "best-of-12" sampling or learned soft-prompts), they could not match the reach of showing on high-between-bin targets.
Exceptions: On low-between-bin targets (e.g., image brightness, where $E/(E+T) \approx 0.17$ ), a strong learned knob did outperform simple bin mixing, confirming the budget's prediction that knobs are sufficient when the target's variance is mostly within bins.

3. Expressiveness and Coverage

Conjunctive Goals: When asked for a batch covering two opposing properties (e.g., "clean vehicles" AND "clean food"), "telling" (prompting) or composing conditions resulted in a "muddy middle" (chimeras). Only showing (mixing a vehicle bin and a food bin) produced genuine instances of both.
Tacit Steering: The framework successfully steered toward "tastes" experts could demonstrate but not name (e.g., a specific aesthetic style) by using examples to infer the bin mixture, provided the cheap key (class label) could distinguish the relevant bins.

4. Training Effects

The paper demonstrates that standard fine-tuning (filtering, RLHF) reshapes the budget predictably. However, if fine-tuning is too aggressive and the model leaves its training distribution entirely, the data-side budget no longer applies, and the model must be audited directly.

Significance and Claims

The paper claims that the "Steering Budget" provides a fundamental, model-agnostic understanding of generative steering:

Predictability: Practitioners can measure the budget on training data to know in advance whether they need to switch from prompting to exemplar-based steering.
Structural Explanation: It explains why per-output optimization (the standard in RLHF and fine-tuning) inevitably leads to a loss of variety (mode collapse) because it collapses the between-bin spread ( $E$ ), which is the only source of collection-level diversity.
Expressiveness: It validates that "showing" is the only mechanism capable of steering toward targets that are inherently disjunctive or tacit, as these targets live in the between-bin budget which "telling" cannot access.

The authors emphasize that this is not a new generation technique, but a quantitative account of the limits and capabilities of existing techniques (prompts vs. examples), derived directly from the statistical properties of the data.