Inverse Scaling › Worked Example: Demonstrating Inverse Scaling

To make inverse scaling concrete, let us trace through a specific distractor task at two model sizes, step by step. We will construct a problem, show how a small model and a large model would each approach it based on their learned patterns, and identify exactly where the large model's greater capability leads it astray.

The task setup: We present the following prompt to models of different sizes:

The correct answer is 12. The number 73 is completely irrelevant to the arithmetic question.

Step 1: Small model processing (125M parameters)

The small model has learned basic arithmetic from training data, but its contextual integration is weak. When it processes this prompt, it identifies "7 + 5" as the operative question and computes the sum. It has seen enough arithmetic examples to know that "7 + 5 = 12" and produces this answer. The distractor number 73 is present in the prompt, but the model's limited capacity for contextual integration means it does not strongly incorporate it into the computation. The model essentially treats the context sentence as background noise, not as a data source for the arithmetic. Result: 12 (correct).

Step 2: Large model processing (6.7B parameters)

The large model has developed powerful contextual integration. When it processes this prompt, it recognizes a structure common in math word problems: a context sentence giving numerical information, followed by a question. In the large majority of such examples in training data, every number in the context was relevant to the question. The model has learned this pattern thoroughly. It sees 73 (the library book count), 7, and 5, and its pattern-matching capability fires strongly: "this is a math problem with three numbers." It may compute something involving 73, perhaps $73 - 7 - 5 = 61$, or it may treat 73 as one of the operands in a more complex expression. Result: likely incorrect, influenced by 73.

Step 3: Identifying the failure mechanism

The small model's weaker contextual integration is an accidental advantage here: it does not have the capability to be fooled by the distractor. The large model's greater capability is what creates the failure. Its more thorough learning of math-problem structure includes the expectation that all numbers in the context are relevant, and this expectation is what the distractor task exploits. The failure is not a comprehension failure: the large model understands the question perfectly well. It is a prioritization failure: the model's learned heuristic about math problem structure overrides its ability to simply extract and compute the stated arithmetic.

Step 4: Numerical quantification

We can verify the distractor susceptibility pattern quantitatively. If a model assigns probability $p_{\text{correct}}$ to the correct answer (12) and probability $p_{\text{distractor}}$ to a distractor-influenced answer (involving 73), then the distractor influence rate is:

$$r_{\text{distractor}} = \frac{p_{\text{distractor}}}{p_{\text{correct}} + p_{\text{distractor}}}$$

where:

• $r_{\text{distractor}}$: the fraction of probability mass allocated to distractor-influenced answers
• $p_{\text{correct}}$: probability assigned to the correct answer (12 in our example)
• $p_{\text{distractor}}$: probability assigned to any answer that incorporates the distractor value (73)

For small models, $r_{\text{distractor}}$ is near zero because $p_{\text{distractor}}$ is very small. The model's weak contextual integration means it assigns minimal probability to answers that involve 73. For large models on distractor tasks, $r_{\text{distractor}}$ can be substantially higher because the model has learned to treat all context numbers as relevant, increasing $p_{\text{distractor}}$ at the expense of $p_{\text{correct}}$.

Step 5: Interpreting the result

The worked example reveals the precise mechanism at work: not a failure of arithmetic or language understanding, but a failure of contextual filtering. The larger model has a more sophisticated model of what math word problems look like, and that sophistication is exactly what the distractor task exploits. The task is adversarial in the technical sense: it is specifically designed to put training distribution knowledge in conflict with correct behavior. This is why inverse scaling tasks are scientifically valuable: they reveal the gap between "the model learned the right patterns" and "the model will always do the right thing."