Quantifying Elicitation of Latent Capabilities in Language Models
Authors: Elizabeth Donoway
Hailey Joren
Arushi Somani
Henry Sleight
Julian Michael
Michael R DeWeese
John Schulman
Ethan Perez
Fabien Roger
Jan Leike
Venue: NeurIPS 2025 poster ()
Keywords: elicitation
large language models
LLMs
latent capabilities
minimum description length
Primary area: deep_learning

Abstract: Large language models often possess latent capabilities that lie dormant unless explicitly elicited, or surfaced, through fine-tuning or prompt engineering. Predicting, assessing, and understanding these latent capabilities pose significant challenges in the development of effective, safe AI systems. In this work, we recast elicitation as an information-constrained fine-tuning problem and empirically characterize upper bounds on the minimal number of parameters needed to achieve specific task performances. We find that training as few as 10–100 randomly chosen parameters—several orders of magnitude fewer than state-of-the-art parameter-efficient methods—can recover up to 50\% of the performance gap between pretrained-only and full fine-tuned models, and 1,000s to 10,000s of parameters can recover 95\% of this performance gap. We show that a logistic curve fits the relationship between the number of trained parameters and model performance gap recovery. This scaling generalizes across task formats and domains, as well as model sizes and families, extending to reasoning models and remaining robust to increases in inference compute. To help explain this behavior, we consider a simplified picture of elicitation via fine-tuning where each trainable parameter serves as an encoding mechanism for accessing task-specific knowledge. We observe a relationship between the number of trained parameters and how efficiently relevant model capabilities can be accessed and elicited, offering a potential route to distinguish elicitation from teaching.

Quantifying Elicitation of Latent Capabilities in Language Models
Elizabeth Donoway
Hailey Joren'
Henry Sleight
Arushi Somani!
John Schulman
Julian Michael
Michael DeWeese*
Ethan Perez!
Fabien Roger!
Jan Leike
Anthropic, University of California, Berkeley, CConstellation, "Thinking Machines, SScale Al
Abstract
Large language models often possess latent capabilities that lie dormant unless explicitly elicited, surfaced, through fine-tuning prompt engineering. Pre- dicting, assessing, and understanding these latent capabilities pose significant challenges in the development of effective, safe Al systems. In this work, recast elicitation as an information-constrrine fine-tuning problem and empir- ically characterize upper bounds the minimal number of parameters needed to achieve specific task performances. We find that training as few as 10-100 randomly chosen parameters several orders of magnitude fewer than state-of- the-art parameter-efficient methods-can recover up to 50% of the performance gap between pretrained-only and full fine-tuned models, and 1,000s 10,000s of parameters can recover 95% of this performance gap. We show that logistic curve fits the relationship between the number of trained parameters and model performance gap recovery. This scaling generalizes across task formats and do- mains, as well model sizes and families, extending reasoning models and remaining robust to increases in inference compute. To help explain this behavior, we consider simplified picture of elicitation via fine-tuning where each trainable parameter serves an encoding mechanism for accessing task-specific knowledge. We observe relationship between the number of trained parameters and how effi- ciently relevant model capabilities can be accessed and elicited, offering potential route to distinguish elicitation from teaching.
Introduction
Many recent efforts in advancing the capability frontier of large language models (LLMs) focus post-training methods, such as fine-tuning, reinforcement learning with human feedhack, or prompt engineering. In many cases, these methods easily achieve significant performance gains through small adjustments to model, suggesting pre-existing capabilities that need only be unlocked rather than taught. As result, evaluations intended benchmark maximal performance can underestimate a model's iss true capabilities [1], leading to an "elicitation gap" between its actual ceiling performance and the capabilities it ordinarily demonstrates. This poses challenges in accurately predicting the
"Correspondence donoway@bezkeley..o edu
Code https:://////
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

model's s behavior once released, with broader safety implications in ensuring deployed models aren't t capable of causing harm.
Prior work that aims to extrapolate LLM capabilities has focused on the impact of scale-compute. data, or model size-on the improvement of model capabilities [2]. We propose complementary framework that takes these as constant and instead varies the number of trainable parameters available during fine-tuning. Since all information contained in a model is stored in its parameters, we use this trainable parameter count as a direct proxy for the information budget available during fine-tuning. We then reconsider elicitation in terms of the minimal amount of information a model requires to demonstrate a capability, and we propose this quantity as an indicator of whether the capability had already existed within the model prior fine-tuning.
We find that fine-tuning only a tiny fraction of a model's parameters often suffices to recover most of its latent capabilities, even when those parameters are selected completely random (Figure 1). Training as few as ~ ~10-10* randomly chosen, low-rank adapter weights can close 50-95% of the performance gap between zero-shot and fully fine-tuned LLMs across multiple choice and natural language generation tasks that span a variety of domains, including long-context chain-of-thouge reasoning. We identify Pareto frontiers of performance versus parameter count when models are elicited, which assume no prior information about model internals. These frontiers reveal a logistic relationship between elicited performance and the logarithm of the number of trainable parameters (logistic in log-p), steep initial improvements that asymptotically plateau approaching the model's 's full parameter count. We find that this behavior generalizes across task formats (multiple choice and natural language generation), subject domains, and model sizes and families, including reasoning models.
Our approach may help distinguish elicitation, in which latent capabilities are surfaced, from teaching, wherein the model learns a new skill. We validate our approach by computing Pareto frontier curves on identical randomly initialized models, where our approach finds (as expected) that recovering even 50% of the performance when teaching complex capabilities from scratch requires several orders of magnitude more parameters than elicitation.
Our main contributions are:
Elicitation frontiers. We empirically characterize how elicited performance scales with the number of randomly selected trainable parameters across ten benchmark tasks, four model sizes, and two model families (Llamaá and Qwen2.5) and find that training only -10' parameters can achieve 50-95% of the performance achieved by fine-tuning all model weights.
Information-theorete interpretation of elicitation. We present a picture of elicitation built upon Rissanen's 's Minimum Description Length (MDL) principle [3] to quantify how much must be specified to a model for a latent capability to manifest, if one exists.
3. Distinguishing elicitation from teaching. We observe qualitative differences in the information models use to represent tasks when relevant capabilities are pre-existing versus absent, proposing that elicitation can be interpreted model's ability develop short descriptions of how to effectively utilize latent skills.
2 Related Work
Parameter-efficient fine-tuning. Parameter-efficient fine-tuning (PEFT) methods that freeze most of model's weights while training only small auxiliary module have become standard practice for adapting large language models to downstream tasks. Adapters [4] insert lightweight MLP blocks, while prefix-tuning [5] prepends trainable vectors, and LoRA [6] injects low-rank adapters. Despite using significantly fewer parameters than full fine-tuning, LoRA often nearly matches its performance, indicating that adaptation information can be highly compact [7]. Recent approaches like DoRA [8], PiSSA [9], BitFit [10], and sparse fine-tuning methods [1 1-14] reduce parameters further without significant performance loss, and small subsets of model weights have been shown to significantly impact model performance [15], collectively highlighting model overparameterization. Our work explores the extreme lower bound of parameter efficiency, demonstrating substantial gains from training as few as 10-100 randomly selected parameters, far fewer than existing approaches.
Scaling laws and information-theoreds bounds. Recent work on scaling laws characterizes performance improvement with increased compute, data, total model parameters [2, 16, 17].

---

1.0
0.9
Test Accurrayy
0.8
0.7
0.678
0.613
0.6
0.521
0.5
0.4
101
10a
10'
10
Number Trainable Parameters
Model Size
1B
3B
8B
Logistic fit
8-shot accuracy
104
12838
9589
Parameters Needed
2752
3048
2403
103
487
1036
263
304
102
39
33
10a
100
50%
75%
90%
95%
Accuracy Threshold (% Gap Closure)
Figure I: Fine-tuning only 10-100 randomly selected parameters recovers 50% of performance gap between zero-shot and fully fine-tuned models. (Top) Logistic fits (solid lines) Pareto frontier points (circles) with bootstrapped 95% confidence intervals (shaded regions) for Llama models of sizes 1B, 3B, and 8B parameters fine-tuned on indicate the 97.5 percentile eight-shot accuracy for each model. (Bottom) Minimum number of trained parameters at which various levels of gap closure (50%, 75%, 90%, and 95%) are or exceeded for each model size (IB, 3B, and 8B parameters).
Dashed lines
Complementing this, our "elicitation frontier" explicitly focuses on the minimal parameter budget required for task adaptation. Our parameter-based approach builds on top of Rissanen's Minimum Description Length (MDL) [3] principle and related work [18] that relates the utility of particular model capability during training to the amount of information contained in the training dataset.
Lottery tickets and strates that sparse subnets ("winning tickets") can match dense performance but requires expensive search. Our findings show random-paraman parameter selection achieves nearly identical Pareto frontiers without specialized search, suggesting that adaptation information both compact and distributed throughout the model.
hypotheses. The Lottery Ticket Hypothesis [19] demon-
Methodology
3.1
Base models & PEFT setup
In our experiments, we fine-tune a randomly chosen subset of a model's parameters to convergence on different tasks using their public train sets, and measure how performance on held-out data varies with the minimum number of parameters needed to specify the updated weights of the fine-tuned model.
Models and baselines. We fine-tune widely used language models from the Llama and Qwen families (Llama 3.2 1B/3B, Llama 8B, Qwen2.5-1.5BB [20, 21]. The models used in our experiments are all pretrained base models, unless otherwise noted.

---

We compare with full fine-tuning, which trains all parameters in the model and defines each model's upper performance ceiling, zero-shot accuracy or loss (performance floor) and eight-shon accuracy prooppt-based elicitation, where applicable) for each model, as well as standard LoRA. In binary classification tasks (BoolQ,
we also compare performance with that of trained, task-specific classifier head on top of the unembedding layer of the base model, as well as linear probe trained directly on the representations of the middle two layers of the model. Additional details can be found in Appendix A.
Parameter selection and fine-tuning. We select random subsets of LoRA parameters (rather than performing structured choice or searching for optimally efficient parameters) random selection requires no prior information about the model's internal representations. This eliminates the possibility that additional information could effectively be used for elicitation but remain unaccounted for. In experiments that train random subsets of parameters within the LoRA modules, learnable subsets of the LoRA adapter matrices are trained while the remaining adapter weights are held frozen their initialized values. We select these trainable parameters using uniform random sampling across all LoRA modules in all layers, with each parameter having equal probability of selection regardless of its position in the network. This selection is implemented by applying random binary mask over gradients during the backward pass, preserving gradient updates only for the selected parameters.
All fine-tuning experiments use AdamW as the optimizer [22], except in experiments training fewer than 20 parameters, where also perform Bayesian optimization directly on model parameters [23], which often outperforms gradient descent and offers a - -100-500x improvement in training time (GPU hours). However, first epoch cross-entropy loss, which is not computed in Bayesian optimization.
gradient descent for all MDL calculations as prequential coding relies
In all experiments, we train until convergence, regardless of the number of epochs required. To verify that only the intended number of learnable parameters has been updated during training, we compare the weights of the LoRA modules at initialization to the weights following fine-tuning and ensure that only the unmasked parameters have been updated. See Appendix C for additional details about fine-tuning procedure details and hyperparameter selection.
3.2 Datasets
We fine-tune and evaluate on classification tasks and 4 generative tasks: GSM-SK-CoT-Choice (a CoT correctness classification task, see Section D.1 for dataset details), ARC-Easy, ARC-Challenge [24], and BoolQ [25] for classification tasks, and Alpaca [26). Ttoy-Stories [27], Lichess chess puzzles, and s s1K-Qwen-1.3 1.5B 3 for generation tasks. For reasoning model experiments,
also evaluate AMC24 and AIME25 (competition math problems), both of which were released after the release of Qwen2.5, to ensure that test set questions cannot have appeared in train data. For all three datasets, we sample 16 responses per question ((emperature=0.6) to estimate pass @ 1 and majority response (maj @ 16). We also evaluate AIME24 using the same sampling method to enable comparisons with previous work. For Alpaca, we evaluate the win rate of each fine-tume fine-tuned model against the best full fine-tuned model when generating answers on Alpaca-Eval (temperature 0). using Anthropic's internal preference model used for training Claude Sonnet 4 as a judge.
4 Empirical Results
4.1 Fine-tuning 100 randomly-chosen parameters often achieves over 50% % performance gap closure on classification tasks
Elicitation Pareto frontier. Following the procedure of Appendix E, we select a sequence of trainable parameter budgets spanning from single parameter to the full set of LoRA adapter weights for ranks 1-1024, addition to all parameters the full model (full fine-tuning). We define the empirical frontier as the average accuracy achieved across all seeds for the best set of hyperparameters for each parameter budget. Figure I (top) plots the resulting frontier points for 1SM-8K-CoT-Choole on log-scale x-axis, along with the best-fit generalized logistic curve and corresponding bootstrapped 95% confidence intervals.
*sIK-Qwen Qwen- is an adaptation of sIK [28] which uses prompts from the sIK dataset with completions generated by DeepSeek-R. R1---R---0 RI-QQen- 1.5B (DeepSeek RI distilled into wwen2.5-Math-11555

---

Gap closure. To quantify how many parameters are needed for common performance targets, we compute the budgets which the given performance gap recovery thresholds are met, with the extent of performance gap defined as the difference between the full fine-tuned model's performance (or maximum of the logistic fit, whichever higher) and its zero-shot accuracy.
Figure (bottom) reports these values for the three model sizes. Table reports these values for the 50% and 90% thresholds across all multiple-choice datasets and Llama models, comparing them with the performance of zero-shot evaluation on the corresponding pretrained-only base models and that of the full fine-tuned models with all -10' parameters trained.
Only -30 parameters are required to recover 50% of the zero-shot to fil-fine-tune gap on GSM- 8K-CoT-Choo ToT-Chiice and BoolQ (Figure 10), meaning that adjusting exclusively few dozen randomly selected dimensions across all layers the model can achieve half of the performance gain of full fine-tuning.
The grade-school level science datasets ARC-Easy and ARC-Challenge show a similar overall pattern, albeit with higher parameter requirements than CSM-8K-CoT-Choice likely due to the more specialized scientific knowledge they assess. particular, fine-tuning on ARC-Challenge. composed entirely of questions answered incorrectly by both retrieval-basee algorithm and word co-occurrence algorithm [24], requires significantly more parameters for the smallest model (Llama 3.2 IB) than other tasks well as compared to larger models (Llama 3.2 3B and Llama 3.1 8B), potentially indicating capability acquisition rather than elicitation due to the possible absence of the capability in the 1B model following pretraining. We discuss possible interpretation of this behavior in Section 5.
We observe that larger models also require only few -arameter adjustments to achieve substantial gap closure (Table 1), supporting the hypothesis that larger models already possess most the requisite knowledge and require minimal tuning to effectively demonstrate it. On all multiple-choice datasets, including both ARC datasets, Llama 3.1 SB achieves 50% performance gap recovery with fewer than 100 trainable parameters.
Table 1: Number of trainable parameters required to close various performance (accuracy) gap thresholds on multiple-choice tasks (GSM-8K-Con)) SK-CoT-Choice, ARC-Easy, (RC-Challenge). The extent of the full performance gap is defined as the difference between the performance of the fine-tuned model with all parameters trained (Full FT) and the zero-shot accuracy of the pretrained base model. #Params denotes the minimum number of trained parameters at which the model's performance matches or exceeds 50% or 90% of the gap above the zero-shot accuracy. % Params denotes the percentage of trained parameters at each threshold relative to the size of the pretrained base model backbone. Results for natural language generation can be found in Scction G.I.
Baselines (&Acc.)
50% Gap Closure
90% Gap Closure
Dataset
Model
Zero-shot Full FT #Params
% Params
#Params
% Params
Llama-3.2-1B
47.56
87.46
39
2.67 10
1036
8.38 x 10-5
GSM-8K-CoT-Choice
Llama-3.2-32
48.36
85.21
1.21 x 10-6
2752
8.56 x 10
Llama-3.1-8B
51.27
87.46
77
9.58
10-7
2403
3.80 x 10
Llama-3.2-1B
24.81
76.45
216
1.74 10
4144
3.35 x 10
ARC-Easy
Llama-3.2-24
74.08
87.06
774
2.41 x 10-5
159k
4.95 x 10-3
1lama-3.1-88
80.46
91.27
99
1.28
10-6
318k
3.96 x 10
Llama-3.2-10
24.21
53.78
3023
2.44
10
154k
1.24 x 10
ARC-Challenge
Jamma332--3B
53.81
75.01
236
7.34
10
3077
9.58 x 10-5
Ilama-3.1-88
61.11
82.66
98
1.22
10
415
5.17 x 10 10-5
4.2 Fine-tuning 1,000 randomly selected parameters achieves 50% gap closure on some generative tasks
When fine-tuning on the Alpaca instruction-tuninn dataset, we observe that training a small fraction of parameters (relative to model size) achieves most of the performance benefits of full fine-tuning for all three Llama models (IB, 3B, and 8B), recovering 50% of the full performance gap in both win
5

---

Alpaco-Eval (Llama 3.1 8B)
TinyStories
Lichess Puzzles 18)
08
Prehaared
Fndturee
0.
107
furdenty trtal
Fandanby infictuu
Pepboatty
10
63
0.5
0.2
101
01
0.
Taatnae Sanumaters
Traimabie
Vrainall Parmmattes
Figure 2: Fine-tuning small random subsets of parameters can elicit better performance on generative tasks. Achieving 50% gap closure on Alpaca-Eve (left) and TinyStories (center) with pretrained Llama models requires training ~1,000 or fewer parameters, whereas ~100,000 parameters more may required when teaching new, complex capabilities for both story generation (center) and optimal chess move prediction (right) tasks.
AMC24
AIME24
AIMEZ5
0.8
0.0
..483 Dreadlont Ducil Daver
par01
paegg)
Accuracy
Accurscy
0.4
PAUSS
Ovevial
04
2.4
0.0
200
3.27
309
30F
20 122
122
207 222
10
1.7
Talnablc camcctos
Toinabic Poramotors
Tolnablc Foromectors
Figure 3: Distillation of DeepSeek R1-style reasoning scales logistically. Fine-tuning Qwen2.5- 1.5B on 1,000 unique reasoning traces generated by DeepSeek-RR Li--issiileed-wwee 1.5B (a post- trained Qwen2.5 model distilled from DeepSeek-RI using supervised fine-tuning, performance indicated by dashed lines) results in similar trends as observed for Llama models fine-tuned on multiple-choice and generative datasets, suggesting generalization of elicitation scaling behavior to reasoning tasks and models in other families. For all three datasets, both majority voting (orange) and pass@1 @ (blue) estimated from sampling 16 responses (temperature=0.6) recover similar logistic scaling with increasing trainable parameters (log-scale x-axis). Error bars indicate standard errors over 16 samples.
rate and loss improvement (Figure 2, left panel, & Figure 7) on Alpaca-Eval with -1,000 learnable parameters (all models).
When fine-tuning Qwen2.5-1.5B on math reasoning traces from DeepSeek- Biieeek-R--Disssee Dww.iiilll-ee--..... find it requires a larger number of trainable parameters to close the gap, reflecting the relative difficulty of the task. For both exact match accuracy (maj@) 16) and loss improvement base model's performance and calculated against reference solutions generated by DeepSeek-R Histill-Qwen-L..
AMC24 (over the
10,000000000000 trainable parameters are sufficient to achieve 50% gap closure (Figure 3 & Figure 8).
Simpler casier tasks, such TinyStories, that make use of capabilities which are already salient in the model largely require fewer trainable parameters to saturate task performance or achieve various performance thresholds, with the necessary parameter budgets appearing correlated with (assumed) task difficulty.
4.3 Logistic scaling of elicited performance emerges across tasks and models
We find a logistic relationship between the task performance and the logarithm of tuned parameters, across multiple-choiee tasks despite them covering different domains and using different formats (Figure 4), and most generation tasks (Figure 2), including reasoning tasks (Figure 3). While the absolute performance levels and the exact number of random parameters required for specific gap closure thresholds vary across tasks and models sizes, the characteristic S-curve shape log- parameter space remains consistent.

---

GSM-BE.CoT-Chaicc
ARC-Easy
ARC-Challenge
1.0
1.0
1.0
0.9
0.8
0.7-
0.77
0.7
0.5-
0.5-
0.6
0.4
0.4
0.4
16
107
107
10
10a
0.2
107
10a
16a
16'
10P
0.2
10
107
105
10"
10a
Number of Thainable Parameters
Number of Thwinable Parameters
Number of Trainable Parameters
Model Size
18 3B
Logistic fit
Figure 4: Logistic scaling patterns emerge across multiple tasks and model sizes. Each subplot shows model performance (y-axis) for all random seeds on a different task (from left to right: GSM- 8K, ARC-Easy three model sizes (1B, 3B, 8B). Solid lines indicate logistic fits to Pareto frontier points, with shaded regions denoting bootstrapped 95% confidence intervals. Consistent scaling behavior a function of trainable parameters suggests that general features broadly characterize elicitation patterns and asymptotic model performance across task types, dataset difficulty, and model size.
against the number of trainable parameters (x-axis, log scale) for
To verify that the observed logistic relationship is not an artifact of the specific functional form chosen, we evaluate several alternative scaling relationships (power law, saturating exponential, and piecewise linear with power law). Quantitative model comparisons using Bayesian and Akaike information criteria consistently favor logistic fits across all datasets and models (see Appendix F for detailed comparisons). The consistency of these fits across models and tasks, independent of the performance metric used, suggests that the observed scaling behavior reflects an underlying, common relationship between elicited capability level and the logarithm of parameters, rather than being an artifact of our analysis approach.
4.4 Stability of Pareto frontier and robustness of logistic scaling across random initializations
Figure 4 shows the distribution of pighest-performing models at every parameter budget for every random seed, rather than just the nominal Pareto frontier points. Each point indicates a model fine-tuned with a unique random seed; opaque points correspond to the Pareto frontier, with solid line logistic fits to the frontier-defining points. We observe that the Pareto frontier is insensitive to seed and that the highest performing runs for all seeds overwhelmingly lie within the 95% confidence interval of the fit to the actual frontier.
While there is naturally some variation across random initializations of the LoRA matrices, as well as which modules and layers are adapted, the overall pattern of rapid performance improvement with minimal parameters is consistent. The logistic trend also remains visible across seeds, even with suboptimal hyperparameters (Figure 12), and we observe similar, but shifted, logistic fits independent of optimization effort or method.
4.5 Distinguishing elicitation and teaching in pretrained and randomly initialized models
To study qualitative differences between elicitation and teaching, we compare the performance of pretrained and randomly initialized variants of the same model architecture (Llama 3.2 1B) to isolate the effects of a model's relevant, existing task representations on its elicited performance. We focus on two tasks which can be learned without pre-existing language knowledge or capabilities: TinyStories, simple English short story language modeling task, and mate-in-N chess puzzles sourced from Lichess"; ; both these tasks use limited vocabularies, require only short context lengths, and have large enough training sets that 1B parameter model can learn the relevant capability.
For TinyStories, a much easier task for a pretrained model that already understands language. achieving equivalent performance levels (set at 50% gap closure in the pretrained model) requires
'Mate-in-N in-N chess puzzles reduce the depth of tree search needed to find optimal moves, both simplifying the task of judging model's win capacity and forcing more difficult learning curve.
7

---

training more than seven orders of magnitude more parameters in the randomly initialized model than in the pretrained model. For Lichess puzzles, a significantly more difficult task that likely requires teaching for both model variants", this parameter gap is less than an order of magnitude and 50% gap closure requires more than trainable 100,000 parameters.
5 Minimum Description Length
Rissanen's Minimum Description Length (MDL) principle [3] formalizes Occam's razor as the notion that the best model of dataset is one that provides the simplest explanation, or shortest description, for it. MDL frames algorithmic learning as optimal data compression, in which models that can reconstruct task data from shorter descriptions are said to have learned more about the task.
Perez et al. [18] find that a capability useful to a model if and only if it decreases the length of the model's 's shortest description of the dataset. By computing computationally-tree -ttacccaee upper bound on MDL., Rissanen Data Analysis (RDA), it is demonstrated that genuine capabilities always shrink MDL, whereas information accessible to model that is uncorrelated with the data labels does not.
In our setting, we presume that a capability may be latent in the pretrained (base) model Mo and try to elicit that capability on dataset designed to surface it. A small adapter A0, with only & trainable weights serves as a pointer to that capability. If a short message (containing the adapter weights 20s) lets the model compress the subsequent label stream by many bits, the original base model already likely contained a highly structured representation of the task. Conversely. if the MDL shrinks slowly or not at all until & becomes large, this means training did not find small pointer to existing capability, and thus the capability was likely absent and must be learned from scratch rather. MDL. compression, given by the difference in description lengths between frozen pretrained base model and a model with & tunable parameters, 4s = Co- Ls. directly measures how helpful the latent capability is to the model when k parameters are available to specify how to access it, quantifying the intrinsic value of the capability to the task at a specific level of clicitation.
Table 2: An underelicited model versus a model which lacks a capability in MDL terms.
Elicitation regime
MDL (#Bits to encode labels)
Capability presence
Training elicits the capability Training teaches new capabilities
La < Lo (for is small)
Latent, present after training Absent or already clicited
L ~ Lo (for is small)
We compute upper bounds on MDL using prequential coding, encoding each example sequentially using the model trained only on previously observed examples, following the procedure of Perez et al. [18]. Practically, we initialize the pretrained model, present each training example exactly once, perform gradient step immediately after an example (or batch) has been seen, and accumulate the per-token, per-example (per-batch) cross-entropy losses across all examples in the dataset. Full details of this computation and its construction for our particular fine-tuning setting can be found in Appendix I.
5.1 Empirical MDL Scaling and Logistic Behavior
For most tasks and models, MDL compression closely tracks improvements in accuracy, smoothly increasing with (randomly selected) trainable parameter count and eventually saturating at maximal cciling (Figure 5, top right). Both curves follow logistic forms in log- log-parameter space.
For Llama 3.1 8B fine-tuned on ARC-Challenge, the derivatives of accuracy and MDL. compression nearly coincide and share similar qualitative features, such as near- Gaussian behavior. Figure (top right) demonstrates the close tracking of accuracy with MDL compression (in bits). In contrast, for the same dataset, the accuracy and MDL curves for Llama 3.2 IB, along with their respective derivatives, demonstrate significant discrepancies between both each other and the behavior observed in Llama 3.1 8B (Figure 5, left panels).
To quantify information encoding efficiency, we analyze the derivative of the logistic MDL compres- sion curve versus parameters (Figure 5, bottom). The peak in this derivative indicates the parameter
$ Both remain below 0.01% & optimal move accuracy with up to 64 in-context examples.
8

---

Liama 3.2 18 (ARC-Challenge)
Liarna 3.1 8B (ARC-Challenge)
Fronter (acoracy)
Logistic ftt (accurscy)
100
0.82
Pronter (MDL)
MDL Comp wessoooooooo (bits)
Accuracy
Logistic (NDL)
90
Validation Accuracy
200
0.75
20
0.24
1.00
0
0.72
Hrnber laccuracyl
logastc (accurecy)
-20
0.70
Prentier (MDL)
Logistic fit (MD()
160
Accurny twathe
0.07
Peak 176.83)
175
Derivatie
0.05
120
MDL De Denvatve
Accuracy Derivatve
0.30
Peakt 1107 97)
MDL derivative
150
MDL Derivative
0.04
80
9.08
0.88
0.06
75
0.82
0.04
30
0.02
25
0.80
0.00
10 Number of Trainable Paramelers
10
10"
10
Number Trainable Paramelers
Figure 5: Accuracy and MDL compression track each other when eliciting latent capabilities but deviate when the required capability is initially absent in the model. (Top panels) Accuracy (colored, left y-axis) and MDL compression (black, right y-axis) plotted against parameter count (X-axis, log scale) for Llama 3.2 1B (left) and Ilama 3.1 8B (right) ARC-Challenge For 8B, as parameter count increases, MDL compression and accuracy both rise following logistic curves in ee-parrmeter space. In contrast, MDL compression in 1B remains flat up to ~10 parameters, at which point it discontinuously jumps, though accuracy rises smoothly. Shaded regions indicate bootstrapped 95% confidence intervals on logistic fits. (Bottom panels) Derivatives of the accuracy (colored) and MDL compression (black) curves, showing peak rates of change that correspond to highest per per-parameter compression and performance efficiency (vertical dashed lines). Both peaks occur at similar parameter counts for Llama 3.1 8B (right) but are separated by approximately an order magnitude for Llama 3.2 1B (left), indicating significant differences in how efficiently the models are each able to explicitly use the necessary capability to generate simpler models of the dataset, relative the number of parameters trained.
budget at which marginal additional parameters maximally improve dataset compression. Comparing this the accuracy derivative reveals subtle differences between cerrmation-thhoree encoding efficiency and downstream task performance efficiency: in cases where the pointer to the underlying capability requires many epochs of training to find or generate, MDL compression will be low even downstream task accuracy is high at the end of multi-epoch training, which may explain why for both Llama 3.2 IB and Llama 3.1 8B the derivative peak to the right of the parameter peak.
Discussion
In Section 4 and Section 5, we presented two complementary views of elicitation: empiri- cal view, where performance rises logistically with the number trained parameters, and an cntemattion-theorete
view, where the Minimum Description Length (MDL) of the label stream falls as soon as a latent capability is unlocked. Here, we synthesise these perspectives and discuss their implications.
6.1 Linking performance frontiers and MDL compression
Figure and Table showed that training only- -10-10 randomly chosen parameters recovers 50-95% of the zero-shot to full-fine-tune gap. Section 5 then established that the same parameter budgets yield hundreds bits of MDL reduction. Taken together, these results indicate that the logistic frontiers of Section 4 can be viewed analogously compression curves: each additional parameter

---

provides the model with an incremental number of bits it can spend on describing the task. The peak of the logistic curve derivative therefore pinpoints an information threshold beyond which adding capacity yields diminishing returns. Models that already contain the requisite capability (e.g. Llama 3.1 8B on ARC-Challenge) reach this threshold quickly, whereas models that cannot readily access a relevant capability (Llama 3.2 1B on the same task), and may need to learn it entirely, require orders of magnitude more parameters before significant reductions in MDL occur.
6.2 Practical and safety implications
Evaluation gaps. Benchmarks relying on zero-shot or in-context performance may underestimate model's 's true capabilities by a large margin. MDL may provide useful diagnostic: if a small adapter suffices to significantly improve task performance, evaluators should treat the corresponding skill as present, even if accuracy is low in the frozen state or in prompt- based clicitation settings.
Distributed representations. The success of random parameter selection suggests that knowledge is spread throughout the network rather than localized in specific layers (Figure 8).
Logistic-in-log-aane porammttersss scaling. Consistent scaling patterns across tasks and model sizes hints at possible common property of elicitation that may offer use as a means of predicting future elicitation thresholds for capabilities of interest.
6.3 Limitations
Task diversity. While we have evaluated approach across several classification and generative tasks, none of them have the diversity and complexity of production settings.
Theoretical approximations. Our
analysis relies on approximations such as first-epoch loss as proxy for MDL. More precise formulations that yield tighter upper bounds might reveal additional nuances in the elicitation process.
Random selection. While our random parameter selection approach yields surprisingly strong results, may not optimal. Structured approaches to parameter selection or low cow-probayility "winning ticket" parameter selections or initializations could potentially improve efficiency further. Elicitation methods. There are potentially methods of eliciting capabilities that vastly outperform the current tfth-offthhe-rt, making it difficult to provide tight upper bound on the number of parameters needed for elicitation.
Finite dataset size. The performance we obtain after training k parameters is lower bound on the maximal performance that possible to achieve that capacity, in particular because we only train datasets of finite (and sometimes relatively small) size. This is especially an issue for large where the model has more capacity learn, which might result in our result overestimating gap closure for smaller k.
7 Conclusion
We present a novel framework for quantifying the elicitation of latent capabilities in language models based on the minimum number of trainable parameters required to achieve various performance levels on downstream tasks. We propose quantifying elicitation with an "elicitation frontier," a curve that maps the number of trained parameters to performance improvements. Across 8 tasks and 4 model sizes from two popular model familics, we find that 20- 1000 randomly selected parameters suffice to recover most of the performance gap between zero-shot and full fine-tuning.
Our elicitation frontier framework offers complementary perspective traditional scaling laws, focusing on the minimal information required to unlock capabilities rather than the maximal capacity of models. The consistent logistic scaling relationship we observe across tasks and model sizes suggests that fundamental, shared principles may govern the ways in which capabilities scale with parameter adjustments. Our study complements classic compute- and data-centric scaling laws with an information-centricc perspective: how much must be said to model before it shows what it already knows? Understanding this information budget essential for capability forecasting, responsible deployment, and the design of safe, reliable, and predictable AI systems.
10

---

8 Acknowledgments
J.L. and J.S. proposed the initial idea for the project. E.D, designed and carried out the majority of experiments across all tasks and model sizes and performed the minimum description length (MDL) calculations. H.J. conducted the Alpaca experiments and contributed all related analyses. J.L., F.R., and E.P. provided supervision at various stages. E.D. wrote the paper with input from F.R., H.J., and J.L. E.P., M.R.D., J.M., J.S., and A.S. offered feedback on early versions of the manuscript. H.S. provided logistical and organizational support. We gratefully acknowledge compute resources provided by Scale and Anthropic. We thank Eric Easley, Vivek Hebbar, Alex Cloud, Joe Carlsmith, Sara Price, Aryan Bhatt, John Hughes, Daniel Paleka, and Joshua Clymer for helpful discussions. M.R.D. acknowledges support from the U.S. Army Research Laboratory and the U.S. Army Research Office under Contract No. 1911NF-20---0151.
References
[1] Teun van der Weij, Felix Hofstätter, Ollie Jaffe, Samuel F Brown, and Francis Rhys Ward. Ai sandbagging: Language models can strategically underperform evaluations. arXiv preprint 1rXiv:2406.07358 2024.
[2] Jared Kaplan, Sam McCandlish, Tom Henighan. Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:200J. 00866), 2020.
[3] Jorma Rissanen. Modeling by shortest data description. Automatica, 14(5):465-411, 1978.
[4] Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski. Bruna Morrone, Quentin de Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efffciiet transfer learning for NLP. CoRR, abs/1902.00755, 2019. URL http: httpt:://axxvv..rrree
902. 00751.
[5] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for gemeration. CoRR, Abs/2101.00199 2021. URL https: //arxii://xxvv...///// /twxiv.vvvv///////////a////aaa.. org/ /a//ab///2100 /ttps/.111.........1111111101111
[6] Edward Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li. Shean Wang, and Weizhu Chen. Lora: Low-rank adaptation large language models. CoRR, ahs/2106.09685, 2021. URL.
https://arxis: org/ 2..66.000 0....9956 0985.
[7] Armen Aghajanyan, Luke Zettlemoyer. and Sonal Gupta. Intrinsic dimensionality explains the effectiveness of language model fine-tuning. CoRR, fbs/2012.112255 2020. URL https: httpa///aaxvvvivv /bs/
[8] Shih-Yang Liu, Chien-Yi Wang, Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang- Ting Cheng, and Min-Hung Chen. Dora: Weight-dccomposedd low-rank adaptation. In Forty-first International Conference on Machine Learning, 2024.
[9] Fanxu Meng, Zhaohui Wang, and Muhan Zhang. Pissa: Principal singular values and singular vectors adaptation of large language models. Advances in Neural Information Processing Systems, 37:121038- 121072, 2024.
[10] Elad Ben Zaken, Shauli Ravfogel, and Yoav Goldherg. Bitfit: Simple parfmeter-efficient fine-tuning for transformer-bae
masked language-models. arXiv preprint arXiv:2 10199, 2021.
[11] Jing Xu and Jingzhao Zhang. Random masking finds winning tickets for parameter efficient fine-tuning,
2024. URL https: / arxiv. org/ abs/ 240 02596.
[12] Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning,
2021. URL https: / aawiiv .rrg/ ataaabb//2200 22t./2144.869.11..
[13] Yusheng Su, Chi-Min Chan, Jiali Cheng, Yujia Qin, Yankai Lin, Shengding Hu, Zonghan Yang. Ning Ding. Xingzhi Sun, Guotong Xie, Zhiyuan Liu, and Maosong Sun. Exploring the impact of model scaling on parameter-efficient tuning. In Proceedings of the 2023 Conference Empirical Methods in Natural Lon- guage Processing, page 15062-15078 Association for Computational Linguistics, 2023, doi: 10.18653/v1/ 0023.emnlp-main..o
URL ht http::///// //xx. doi. wrgg10gg1100 18653/66//// /t//////222////////// wwwne-nmaaae
931.
[14] Max Ploner and Alan Akbik. Parameter-efficient fine-tuning: Is there an optimal subset of parameters to tune? In Yvette Graham and Matthew Purver, editors, Findings of the Association for Computational Linguistics: EACL 2024, pages 174-1759, St. Julian's s. Malta, March 2024. Association for Computational Linguistics. URL ht spsttp/s/// / wtt.aaaannnttttoaooooao howggy...ooooo..oo.......o.ooo.. org/ 2024 4, E findings- eacl. 1212/
[15] Mengxia Yu, De Wang. Qi Shan, Colorado Reed, and Alvin Wan. The super weight in large language models, 2024. URL https: http://aaxvvv....../ hwwpe////bb//// http:/2111.111111
[16] Joel Hestness. Sharan Narang, Newsha Ardalani, Gregory Diamos, Heewoo Jun, Hassan Kianinejad,
Md Mostofa Ali Patwary. Yang Yang. and Yangi Zhou. Deep learning scaling is predictable, empirically. arXiv preprint arXiv:1712.00400, 2017.
11

---

[17] Jordan Hoffimann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. Training compute-optimal large language models. arXiv preprint arXiv:2203. 15556, 2022.
[18] Ethan Perez, Douwe Kiela, and Kyunghyun Cho. Rissanen data analysis: Examining dataset characteristics via description length. In International Conference on Machine Learning, pages 8500 8513. PMLR, 2021.
[19] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint 1803vv:880300366 2018.
[20] Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al- Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. The llama 3 herd of models. arXiv preprint 1rXXi:2407.2/788 2024.
[21] Qwen, :, An Yang. Baosong Yang. Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang. Haoran Wei, Huan Lin, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang. Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bao, Kexin Yang. I.e Yu, Mei Li, Mingfeng Xue, Pei Zhang. Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tianyi Tang, Tingyu Xia, Xingzhang Ren, Xuancheng Ren. Yang Fan, Yang Su, Yichang Zhang, Yu Wan, Yuqiong Liu, Zeyu Cui. Zhenru Zhang, and Zihan Qiu. Qwen2.5 technical report, 2025. URL https: /arxiv...vvvvv////////////// . org/ abs / 22122 15115.
[22] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization, 2019. URL attps://arx:: org/ / abs//111-. 05101.
[23] J. Mockus. Bayesian Approach to Global Optimization: Theory and Applications. Mathematics and its Applications. Springer Netherlands, 1989. ISBN 9780792301 158. URL. petttss://boooe goog e. com/books? d-
[24] Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schocnick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv: 0803 05440054 2018.
[25] Christopher Clark, Kenton Lee, Ming-Way Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. Boolq: Exploring the surprising difficulty of natural yes/no questions. In NAACI, 2019.
[26] Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Stanford alpaca: An instruction-Colloiinng llama model. https: /ggthub.. com/ coom/attu--aae saatsuu-aabbste haabb//tafoordd alpaca, 2023.
[27] Ronen Eldan and Yuanzhi Li. Tinystories: How small can language models be and still speak coherent english? arXiv preprint arXiv:2305.07759 2023.
[28] Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishiri,, Luke Zettlemoyer Percy Liang. Emmanuel Candès, and Tatsunori Hashimoto. sl: Simple test-time scaling. arXiv preprint arXiv:2501. /9393, 2025.
[29] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reicchio Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:21 10.14168, 2021.
[30] Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. Journal of Machine Learning Research, 18 (185):1-52, 2018.
[31] Qiong Gao, Ming Li, and Paul Vitányi. Applying mdl to learn best model gramularity. Artificial Intelligence, 121(1-2):1-29, 2000.
[32] A. Barron, J. Rissanen, and Bin Yu. The minimum description length principle in coding and modeling. IEEE Transactions on Information Theory, (4(6))773322666 1998. ISSN 0018-9448. doi: 10.1
720554. URL http: / dx doi orgg 10. 1109/18 720554.
[33] A. Dawid. Present position and potential developments: Some personal views: Statistical theory: The prequential approach. Journal of the Royal Statistical Sociery. Series (General), 147(2):278, 1984, ISSN 0035-9238. doi: 10.2307/2981683. URL http: //xx doi crg/10 2307 2881683.
[34] A Dawid. Prequential Analysis, Stochastic Complexity and Bayesian Inference, page 109 126. Oxford University PressOxford, August 1992. ISBN 17813830,,
doi: 10.0099600077881199522666 000.0000000000.7 URL : / /xxx www.ooooooo/ii 00. 093 oso/ 97801 98522 000.6690000.0000 0007.
12

---

A Baselines
For all tasks, we use three baselines for comparison (zero-shot performance, eight-shot performance. and fine-tuning all parameters of the base model). We define each model's performance floor as its zero-shot accuracy (multiple-choice datasets) or zero-shot win rate (Alpaca). We take each model's highest performance (accuracy or win rate) following full fine-tuning (updating all model weights) as its nominal ceiling performance.
Full fine-tuning, For all models, we fine-tune the entire model until convergence on each dataset. We define convergence as the point where validation accuracy exhibits no improvement for 20 consccutive epochs. Specifically, if |Acc(f) max(Acc(t- 20 t))l < where 10 training terminates. This criterion ensures stable convergence while avoiding premature stopping.
Zero-shot evaluation. For each model, we perform zero-shot evaluation the validation and test sets. Prompts used for zero-shot evaluation are the same as those used for all fine-tuning experiments. Prompt formats for each datasct can be found in Appendix D.
Multi-shot evaluation. We perform multi-shot evaluation similarly, using the same prompt format as used for zero-shot evaluation and prepending randomly selected examples (with properly formatted correct responses for each) from the corresponding train set. The number of shots is equal to the number of prepended train set examples with answers. We use the same formatting for each example, prepending the same train set examples each time, with the final example being the validation or test set example that we evaluate the model's response on, in which the answer field is left blank.
We tested variations with 1, 2, 4, 8, 16, and 32 shots prepended for each model and dataset, finding that 8 shots resulted in the highest performance across the board. We average performance across 30 trials for each number shots to obtain the overall X -hho performance. Every trial uses different random seed that used only to select the specific train set examples that are prepended; the same set of random seeds is used for all models, datasets, and X-shot configurations. We ensure that the prepended examples contain an approximately even split of each answer class to reduce potential sources of bias in the model outputs. Due to variation in performance across seeds, we the 97.5 percentile (2o above the mean) value the distribution of scores an approximate upper bound baseline for model's X- -sot performance.
A.1 Additional binary classification baselines
For binary classification datasets RSS-8K-44 WAMM-K-COT-CCC additional baselines: (i) training a task specific classifier head attached to the unembedding layer the model, and (ii) training a linear probe on the representations of the middle two layers of each model. Figure 6 compares these baselines for Llama-3 3.2- 1B on GSM 8K UK-CoT--hoiie
Ca---Co---hiic and BoolQ, compare the performance of two
Classifier Head. We initialize each model with classifier head that enforces the model's outputs to be one of the two label classes. The classifier head contains twice the number of parameters of the model's hidden dimension. We then freeze the model backhone and train only the weights in the classifier head when fine-tuning on each dataset, taking the highest final evaluation performance at convergence across seeds (s = 5) as the haseline.
Linear Probe.
We initialize each model with all parameters frozen and train a linear probe out the represen- tations of the middle two layers of each model.
B Generative Experiments
B.1
Alpaca
Discussion. Across the Alpaca instruction-tuning runs, win-rate versus trainable- parameter count similarly increases quickly with few parameters (Figure 7). For Llama-3.2-1B, win rate (versus the best full fine-tuned model) jumps from ~0.08 to ~0.71 as the budget grows from 10 to 10 updated weights. The 3B model follows a similar pattern, shifted one decade to the left. Note that overall, the win rate is lower for 8B (compared to IB 3B) as it is caphery base model with relatively higher full fine-tuned performance.
trainable-parmmtter
Dataset and splits. For the open-ended generation experiments we adopt the Stanford Alpaca eesrructio-followiiin corpus. The raw 52k examples are shuffled once with a fixed random seed and par- titioned 90/10 into training (234,006 instructions) and held-out evaluation (26,006 instructions). No additional filtering or augmentation is applied, All results in the main text use the full training split; the "tiny" ablations described below operate the same data but restrict the number of trainable parameters, the dataset size.
13

---

GSM-aK-CoT-Choicc
1.0
Test Accuracy
Full fine-tune
0.8
0.6
Classifier head
Linear probe
0.4
10a
10a
10a
107
10
Number of Trainable Parameters Model Size
1B
Logistic fit
Figure 6: 1lama-3.2-1B fine-tuned LaL---KKCCT---hii with full fine-tune (red star), classifier head (black star), and linear prohe (blue dashed line) baselines.
Prompt construction and tokenization. Each instance is formatted with the standard Alpaca template where the input block omitted when empty. expected answer is appended after prompt. entire sequence is truncated to 256 tokens. During training we follow common instruction-uun tutiiontttninggggg practice and compute loss only on the response: all prompt tokens are replaced with the ignore-index so gradients flow exclusively through the generated portion. The end-of-sequence token is reused as the pad token.
Base models and adaptation strategy. We fine-tune two pretrained Llama-3,2 models- 1B and 3B parameters using low-rank adaptation. Unless otherwise noted, LoRA modules (ranks 1, 2, 16, 256, 512) are inserted on every projection matrix in every transformer block.
To study how few parameters suffice for high-quality generation as an unordered pool and select an absolute number of them to update (1 to full rank). Selection uniform at random over all LoRA weights; the mask is sampled once at the start of cach run and held fixed for the duration of training. In the very-fer fer--few parameter regime (<10k trainable parameters) the original language-mode head remains frozen isolate the effect of the highly sparse adaptation; larger budgets the head fine-tuned together with adapters.
the weights inside the LoRA matrices
Optimization and runtime. Every model is trained for exactly two passes over the 234k-cxample training split. Mixed -eeee-pprciiion (bfloat16) training with FlashAttcntion is employed throughout, and gradient check- pointing is enabled except in the smallest runs. Each experiment fits on a single NVIDIA H100 GPU; no multi-GPU distributed training was employed.
Evaluation protocol. After fine-tuning we generate completions for the 805- 005-example Alpaca evaluation subset using greedy decoding (temperature 0, max 256 tokens). Outputs scored by off-the the-thh--hfff preference model that compares each fine- tune-t model's answer against the corresponding answer from the un adaadpp base model the same size. We report the win rate of fine-tuned model over the comparisons; ties and losses are counted separately but not shown in the main tables.
Summary of reported configurations. Model sizes: Llama 3.2 1B, Llama 3.2 3B, Llama 3.1 8B
LoRA ranks: 2, 4, 8, 16, 256, 512
Trainable-pane rrainbble-paramete budgets: exact counts spanning from just few parameters to nearly full finetuning.
Epochs: (all runs)
Sequence length: 256 tokens
Hardware: single NVIDIA H100 80 GB GPU per run
B.2 Reasoning distillation with s1K rollouts
To determine the parameter efficiency of eliciting reasoning capability in Qwen base models, we generate reasoning traces for all prompts in the s1K dataset [28] using the respective post-trained trained (DeepSeek- RI distilled) version of each model. The cost-trained models used were originally trained by DeepSeek using supervised fine-tuning (SFT) on a large corpus of several hundred thousand reasoning traces generated by DeepSeek-RR R1. We then perform SFT on each original base model using the dataset of the corresponding post-trained model's
14

---

Loss Improvement Trainable Parameters
Win Rate Trainable Parameters
(Llama 1B)
(Llama 16)
0.9
Loss Inprovement (Starting -Best)
0.20
0.8
0.7
0.15
0.6
Win Rate
0.5
0.10
0.4
0.3
0.2
0.00
10a
10a
10
10?
10a
10
10a
10a
10"
10'
10
Trainable Parameters
Trainable Parameters
(a) IB Pareto frontier: Loss improvement
(b) Parcto frontier: Win rate
Loss Improvement Trainable Parameters (Liama 3B)
Win Rate Trainable Parameters (Llama 3B)
Loss Inprovemeent (Starting Best)
0.8
0.20
0.7-
0.15
Win Rate
0.6
0.5
0.10
0.4
0.3
0.05
0.2
0.00
10a
10
10a
10
10a # Trainable Parameters
102
10a
Trainable Parameters
(c) 3B Pareto frontier: Loss improvement
(d) 3B Parcto frontier: Win rate
Loss Improvement Trainable Parameters (Liama 8B)
Win Rate Trainable Parameters (Llama 8B)
Inprovement (Starting Best))
0.25
0.9
0.8
0.20
0.7
0.6
0.15
Win Reta
0.5
0.10
0.4
0.3
0.05
0.2
0.1
0.00
16
10a
10a
10
10a
10a
10a
107
Trainable Parameters
4 Trainable Parameters
(e) 8B Pareto frontier: Loss improvement
(1) 8B Pareto frontier: Win rate
Figure 7: Comparison of loss improvement and win rate for Llama models fine-tuned on Alpaca and evaluated on AlpacaEval (IB, 3B, and 8B). Loss improvement is computed as each fine-tuned model's (blue points) improvement in the cross-entropy loss for autoregressive generation compared to its corresponding base model. Win rate denotes the proportion of responses generated a fine-tuned model (red points) that are preferred by the reward model over responses generated by the best full fine-tuned model. In each graph, single points denote the result of single fine-tuned model with the specified number trainable parameters. The Pareto frontier in each graph is denoted by the opaque points with black outline connected by solid line.
15

---

number of DeepSeek Distill
Layer Anunton V.
FFN
Lose improvement
0.9
0.8
0.7
0.8
0.5-
10,000 20,000
100,000200,000
1,000.000 3,000.000
Trainable parameters
Figure 8: Adapting K, Q, V, O matrices in the self-attention layers (blue points) more parameter- efficient for (sparse uundom-paramett feed-forward network/MLP layers of the transformer block (orange points). For the same trainable parameter budget, adapting weight matrices in the self-attention layers results in higher loss improve- ment the converged, fine-tuned model over the base model's zero-shot loss (results shown for evaluation on the AMC23 dataset). This effect is particularly pronounced when fine-tuning sparse random- parammeerr subsets of the rank-1 LoRA adapters. Differences loss improvement are similar when training all adapter parameters (i.e., "full-rank"), nearly independent of rank and regardless of whether the self-attention or FFN layers in each transformer block are adapted.
LoRA adaptation than adapting G, U, D matrices in the
generations the s1K prompts; we the method for (sparse) LoRA adaptation and full fine-tuning as described Appendix C.
C Fine-tuning details
C.1 Target Modules
We investigate variations in which we adapt all weight matrices within the transformer block, Q, V or Q, V, K, O matrices in the ooffaattetionn layers, G, U, D matrices in the feed-forward network (FFN)/MLP layers, K, Q, V,U, D matrices across the transformer block, and randomly selected subsets of weight matrices across the transformer block. We observe similar logistic scaling behavior of performance learnable parameters across configurations adapted weight matrices.
We find attention-one only tuning (adapting K, Q, V. matrices) is consistently the most parameter-efficcee across all datasets (multiple choice and generative, including reasoning), irrespective of answer format. This suggests that the information needed to activate pre-existing knowledge is not confined to the FFN subspace. Figure 8 compares the loss improvement for 0wen-225-Math-1 fine-tuned on 1,000 reasoning traces generated from R1 Distill-Qwen-1.. model via supervised fine-tuning.
model distilled from DeepSeek-R1 into the same Qwen-2.5-Math- 1,5B base
When we refer to "trainable parameters," we exclusively mean scalar values within LoRA adapter matrices (except in full fine-tuning, in which we directly train the base model's original parameters). For rank-r adaptation:
Matrix A: Rexdia (Kaiming uniform initialization)
Matrix B: Rod (zero initialization)
Total parameters per module: x (din + dout)
C.2
Seed and hyperparameter variation
For each parameter budget, run up 5 random seeds with up 50 Bayesian-Ilyperbandd trials each learning rate, batch size, and weight decay. In experiments, we until convergence (defined as at least 20 epochs with no improvement in validation accuracy for multiple choice tasks, or at least 2 epochs with no improvement in validation loss for generative tasks), regardless of the number of epochs required.
'Prompts used for generating the model reasoning trace rollouts used for supervised fine-tuning were derived from the sIK dataset [28].
16

---

Search spaces.
Parameter search ranges are calibrated based on the number of trainable parameters and GPU
memory constraints:
Learning rate: [10-6 _1] (log-uniform spacing)
Batch size: {1, 2, 4, 16, 32, 64, 128, 256} (discrete)
Weight decay: [0, 0.1] (uniform sampling)
C.3 Multiple-choice scoring
For every multiple-choice dataset, score the model by directly comparing logits of the canonical answer tokens (e.g.. "A""""/"""""" at the final position.
To reduce the dependence of the results on the model's ability to format its responses properly, we additionally run an ablation that sums probabilities over several token variations per option (including different capitalization, synonyms, whitespace). We then calculate loss and accuracy directly using the logits for tokens corresponding to each label class.
For multiple-choice tasks, we assign labels by aggregating probabilities across variations for each ground-truth lahel token:
P(label) = Σ P(token:);
(1)
where token; E ("A", " A", "a", a=") for lahel A (and similarly for all other labels).
We take the softmax of the model's output vector for the final token position to obtain probabilities the outputs for each token the model's vocabulary, and for each label class, we sum the probabilities of differently formatted, single-token variations of each label (e.g.. "A": ("A", A", "a", , a²") for label class A). We use the same set of variations for all label classes (e.g., "Correct": ("Correct", CCrrect", "correct". "correct"). "Incorrect": ("Incorrect", " "Icorreet"" "incorrect", incorreet") with sets of labels for each class incorporating the same variations on spacing and capitalization). This approach ensures robustness minor formatting variations in the model's output while maintaining evaluation consistency.
The two procedures (logit comparison on ground truth labels only versus cumulative probability comparison on variations of ground-truth labels) differ by <0.2 percentage points on average, demonstrating that memorization of the output format does not explain the observed increases in performance.
C.4 Bayesian optimization directly over LoRA adapter weights (ultra-low parameter regimes)
For experiments which fewer than 20 parameters are trained, training until convergence can require more than 1000 training epochs, and training dynamics can become unpredictable with discontinuities observed in the loss. The combination of these factors makes it difficult to identify when training has converged or to explore sufficient hyperparameter configurations effectively resolve the true elicitation Pareto frontier.
To circumvent this issue, in addition training with gradient descent, in the regime of fewer than -20-25 trainable parameters, we also perform Bayesian optimization with a Gaussian process surrogate model and expected improvement acquisition function (GPy Torch with default Matérn kernel) directly on the learnable adapter weights within the LoRA matrices; parameter selection is performed using the same random sampling procedure as in the tradient-descent-basee fine-tuning setting. This approach mitigates optimization instabilities extreme sparsity levels.
For the Gaussian process, parameter hounds were empirically calibrated through preliminary gradient descent experiments:
A 2: 2: 10), [-5,5]
3 10: (-5,)) 1-3,3
. > 25:
where à is the number of trainable parameters. The Gaussian process optimizer directly searches this k- dimensional space, evaluating model performance for each parameter configuration. The same bounds used for all trainable weights (uniform bounding hypercube). We initially uniformly randomly sample from within the bounding hypereube a set of candidate vectors that contains three times as many vectors as the number of trainable weights. Each vector has dimension equal to the number of trainable weights, with each entry in a vector corresponding to an individual trainable weight.
For each candidate vector, we replace the values of the trainable weights in the original LoRA matrices with the corresponding candidate entries and evaluate on the entire train and validation sets. We the initial set of candidate vectors with evaluated accuracies to seed the Gaussian process optimization. We iterate over all candidate vectors, generating up to 400 additional, new candidate vectors with the Gaussian process optimizer. and take the performance from the candidate vector with highest validation accuracy as the final performance (with weights of the final trained parameters replaced with that candidate vector's entries).
17

---

This process entirely eliminates the need for hyperparameter search and significantly reduces training time and overhead, only the forward pass must be computed for optimization. In this very-few parameter limit, find performance from models trained with Bayesian optimization matches or exceeds performance of best performing hyperparameter configurations, enabling us to efficiently sample the elicitation frontier.
Due to the fact that Bayesian optimization docs not employ training epochs, however, we are unable to calculate prequential minimum description lengths for the resulting fine-tuned models. Instead, we calculate prequential MDL only for models fine-tuned using gradient descent.
C.5
Computational Requirements
Hardware: Single NVIDIA H100 80 GB GPU
Runtime: 10 minutes 36 hours depending on parameters trained and total training epochs
Memory: 20-60 GB depending on model size and batch size
Total experiments: -3500 individual runs
D Dataset details and fine-tuning prompts
D.1 GSM-SK-CoT-Choie
CSM-SK-CoT-Choice was created by adapting - 1000 questions from the GSM-8K benchmark [29] to a binary classification task. For each question. four distinct chain-of-thought reasoning solution allempts and answers generated with Claude 3.5 Sonnet. In each example, the model is presented with question, solution attempt, and final answer and asked identify whether the solution attempt and final answer are correct. The dataset is split evenly between correct and incorrect solutions, with two cach per question. During development, one example from each label class per question (one true, one false) was randomly sampled to construct the fine-tuning dataset, and we confirmed similar training dynamics across random seeds. Model- generated solution attempts were rigorously validated by human and additional language model (Claude 3.5 Haiku) to ensure accurate labeling.
D.1.1 Dataset generation procedure for MAM1-8K-CoT-CIAA
We use the following procedure to generate the dataset:
1. Question selection: Sample 1,000 problems from GSM-8K training and validation sets
2. Solution generation: For each problem, generate chain-of thought solutions using Claude-3.5- Sonnet with structured JSON output (2 correct examples, incorrect examples) Answer validation:
Correct solutions: Verify exact string match with ground truth answer
Incorrect solutions: Ensure no match with ground-truth answer
4. Quality control: Manual verification of flagged examples where automated validation fails
5. Balance Verification: Confirm exactly 2 correct and 2 incorrect solutions per problem
6.
Sampling: Randomly sample example from each label class per question
D.1.2 Dataset statistics for WSM-8K-CoT-Chone
Total examples: 4,000 (1,000 questions x solutions cach)
Class balance: 50% correct, 50% incorrect
Token length: 99% of examples 384 tokens (using Llama tokenizer)
D.2 DeepSeek-R1 distilled model generations s1K prompts
dataset used for supervised fine-tuning each hase model was created by generating rollouts (model genera- tions) to each prompt in the s1K dataset [28] using the official DeepSeek-diistilee version of the specific base model, up to maximum length of 32768 tokens (lemperatur=00.6) Following the procedure of Muennighoff' al. [28]. verify that the reasoning traces have the correct format (i.e., thinking portion where initial reasoning carried out, followed by an answer to the user query) but do not regenerate incorrect solutions.
D.3 Fine-tuning Prompts
Systematic evaluation revealed minimal sensitivity to prompt variations when instructions are present (<0.5% performance difference). Without instructions, performance degrades by approximately 2%, motivating our standardized prompt templates.
18

---

D.3.1 GSM-8K-CoT-Choice
You will be given math problem, st.epby-steg solution attempt, and final answer.
Avaluate the correctness of the solution attempt and answer problem.
Respond with ONLY 'Correct' or 'Icorrect.''
Problem: (problem)
Solution Attempt; (solution attempt)
Answer: (answer)
Respond with ONLY 'Correct' or 'Incorrect', Responsc:
D.3.2 ARC-Easy & ARC-Challenge
...
You will be given question and series of answer choices label ed A, B, C, D, etc.
Select the correct answer from the choices. Respond with ONLY the uppercase letter of the correct answer (A-E). Question: (question)
Answer choices:
A: (choice A)
B: (choice B]
(other choices)
Response:
D.3.3 BoolQ
You will be given passage and a question.
Determine the answer to the question based the information in the passage.
Respond with ONLY "Yes' or 'Ne''
Passage: (passage)
Questicn: (question)
Response: '..
D.3.4 Alpaca
...
Below an instruction that describes a task(, paired with an input that provides further context). Write a response that appropriately completes the request.
## Instruction: (instruction)
## Input: (input)
## Response:
E
Preliminaries
Notation. Let D {( = denote downstream task dataset of size denote by t the parameters the pretrained model and by Op.s. LoRA-addpted parameters ontained by training exactly adapter weights with random seed s and hyperparameters h. We write
Acc(O)
Σ
((j(()) #}
(2)
D
19

---

for the validation accuracy of the model 0. We further define the zero-shot baseline Acep Acc(Ob) and the accuracy of the fully fine-tuned model Accratt
Parameter Budget Selection. We select parameter budgets (pi,.... p& on logarithmic scale to ensure adequate resolution across orders of magnitude.
Pareto Frontier Extraction. To characterize the trade-off between parameter budget and performance, choose set of budgets p (pi....,Pk ). For each budget p, we perform:
S 3-5 independent random seeds
For each (p, 8), up to 50 hyperparameter trials via Bayesian optimization with Hyperband [30].
Record the maximal validation accuracy
f(p)
max Acc(Op.s.h)-
(3)
The set of points {p, f(p)) K its flexibility in modeling diverse S-shaped growth patterns:
p=1 defines the empirical Pareto frontier. We fit a generalized logistic in log for
Acc. Acca
f()) R Acc
(4)
(1 + exp (-a b log
using nonlinear least squares recover (Acco, Acc a. v). This formulation accommodates asymmetric growth curves observed across different tasks.
Bootstrap Confidence Intervals.
We employ nonparametric bootstrap with 10*-10* samples:
For each iteration, remove one frontier point uniformly random
2. Fit logistic curve remaining points
3. Compute 95% confidence intervals from empirical distribution of fitted parameters
Empirical Metrics.
We evaluate two additional quantities on the frontier models 0p. achieving f(p):
1. Gap closure:
GC(p) f(p) Acco
E [0, 1].
Accral Acco
2. Online MDI. [3, 31];
MDL(p) = MDL(p)= ((p.rr Ni, V:),
1=1
where is the per-example training loss, which is updated after each example (or batch) has been processed, and the sum is taken over the first epoch only, such that each train example has been exactly once by the model.
F
Analysis of alternative fitting functions
F.1
Alternative fitting functions
We analyze four alternative fitting functions in addition to generalized logistic: saturating exponential, power law, (piecewise) broken power law, and smooth broken power law (power law multiplied with a logistic window to maintain diffcrentiahility..
Generalized logistic:
γ Umin + Hmax Hmin
(5)
20))
Saturating exponential:
ÿ = Vmax Ae - B((--a))
(6)
Power law:
y = ax
Broken power law:
ba
for x me for >
y
+ bork + c(xx )d
(8)
20

---

Smooth broken power law:
+ be
for << 2k for x > ax
(9)
box + c(x =x
F.2
Model comparison metrics
We evaluate model fit using:
Akaike information criterion (AIC): 2k 21n f.
Bayesian information criterion (BIC): Inn In L
Mean square error (MSE):
E,( 1.)².
where & the number of fitting parameters (not trainable parameters this instance), n is the number of data points (i.e., the number Pareto frontier points used for generating fitted curve), and L the maximized likelihood (sum of squared errors). Figure shows the results of curve fitting for all three Llama model sizes (IB, 3B, and 8B) fine-tuned on GSM-8K-Coff
with corresponding AIC and BIC for cach fit.
G
Results from additional datasets
G.1
Alpaca
Figure 7 shows results from fine-tuning Llama-3.2-18 and Llama-3.2-3B on the Alpaca instruction-tuning
datasct.
G.2 BoolQ
Figure 7 shows results from fine-tuning Llama-3.2-18 and -lama-3.2-3B on BoolQ. The logistic scaling of accuracy with increasing trainable parameters remains consistent in BoolQ. with both models requiring 100 parameters to achieve 50% performance gap closure between zero-shot accuracy fine-tur sunetune accuracy.
G.3 Dataset Coverage Limitations
BoolQ and Alpaca experiments include only Llama-3.2-11 1B and 3B models due to computational constraints. The consistent logistic scaling observed across completed experiments suggests similar patterns would emerge for model, though empirical validation remains future work.
H Results across hyperparameter and seed variations
Because fine-tune with numbers trainable parameters spanning several orders of magnitude, we optimize hyperparameters at each parameter budget each seed, performing up to 50 trials of Bayesian optimization with Hyperband. Figure 12 shows results for hyperparameter optimization trials for Llama 3.2 1B (top) and Llama 3.2 3B (hottom) fine-tuned on ARC-Fasy (all seeds). Hyperparameter optimization is required for each parameter budget hyperparameters (learning rate, in particular) differ significantly depending sparsity trainable parameters. For highest performing seeds, as shown Figure the highest performing runs for each seed demonstrate little variability in final validation accuracy and largely fall within the 95% confidence interval of the fit to the Pareto frontier.
the
Construction of Prequential MDL and RDA
Because the true Minimum Description Length is uncomputable, Perez et al. [18] propose to upper bound it with the data's MDL obtained by prequential coding:
C(y.N) fI,N L(yix) m1:)),
(10)
which states that model that domain-relevant capability generate label obtains compact explanation of label-generation process, which enables succinctly model dataset itself.
We can alternatively view this label- label- generation learning process as a communication protocol sending labels for the dataset from someone who has them to someone who does not. Alice, who has the labels, wants to share them with Bob, who does not, and they want to find the smallest file Alice needs to send to Bob so he can have them. Alice and Bob share the same base model A and learning algorithm A (which contains all
21

---

Pareto
0.-
Tet
0.
02
Paieto Frenter
Saturatnng Exponential (AKC: 23 BIC. d6
Geners and Logeric (VC) 18.8, RCC: 41.3
Brossn Rower Las (MC) 25 BIC: 48.51
Smooth Broken Power lax (AC:: 25,9, BIC: 41.4)
Rega an Power Lan (AC: 23 B1C 48.41
101
107
10'
10P
Number Tninaaaee Parameters
Frontier
Tet
Partto Trentier
Seturating Exponentaal IAC: 24.8 BIC: 42.3
Generai lee Logiatic (AIC 13.5 BIC: 33.3)
Broisen Power Lan (ACC 25.3, BIC: 45
Smoon Brosen Phwrer lax (MC: 28,8, 48.83
Regu or Poweer Law (MI: 20
16
101
12" Number Trataale Parameters
107
101
Uama Pareta Frontler Curves
3.0
0.
0.6
Bec
Parsto Fronteer
Suturating Exponential (AKC: 26.0 SIC, 41.5)
Genero ized Logitik (A/), 18.2. SIC, 35-00
44.21
Sireoth Power Law 27.0. 44.8)
Rogu ur Power Law JMC.
29'
10P
16ah
10'
Number Trainasoo Narumetess
Figure 9; Fitting of curves with corresponding AIC and BIC for IB, 3B, and 8B Llama models fine-tuned on WSS--K-CoTT-Chee For all models, AIC and BIC are consistently lowest for fits to generalized logistic function.
22

---

BoolQ
1.0
Test Accuracy
0.9
0.8
0.7
0.6
0.5
10a
10a
10a
107
10a
Number of Trainable Parameters
Model Size
1B
38
Logistic fit
19403
Parameters Needed
104
4971
10a
722
361
237
147
126
10
74
10
100
50%
75%
90%
95%
Accuracy Threshold (% Gap Closure)
Figure 10: Fine-tuning ~10 parameters in Llama-3.2-1B and Llama-3.2-3B recovers 50 % of the performance gap BoolQ. 2a standard errors are shown as shaded regions.
information Bob needs to know to replicate Alice's 's training on end), update the model after cach label, and code that label with its instantancous cross-entrope loss, This "online" code length converges in expectation to the true MDL when the learner (i.e., model) is Bayes-optiml.
Perez et al. [18] introduce Rissanen Data Analysis replace MDL with a block-wise code that retrains the model (calculating loss and updating gradients) only after a batch of examples has been seen, until all examples dataset have been seen single time. This still constitutes an upper bound on the minimum information Alice must send because each batch is encoded with a less recent model than in the prequential setting.
Canonically, RDA either keeps the model architecture and optimizer fixed or charges log, M additional bits if ensemble of M learners is allowed, averaging codelengths over five random seeds. We adopt the same formulation.
We additionally ask the question, "How much do you have to specify to the model to it to demonstrate knowledge already has?". An intuitive way measuring how much guiding model needs be able access (some fraction of) a pre-existing capahility by counting the number of parameters that must be updated he able to achieve certain performance threshold on a task that requires the skill. In our elicitation framework, we employ MDL to measure how efficiently model can encode task labels during its initial exposure to the training data. We compute MDL using the first epoch of training from randomly initialized LoRA adapter, not from a converged model. as this provides measure of how quickly a model can develop an efficient task representation given minimal parameter updates.
to
Comparing MDL and final test accuracy for a given model then provides information about how well model can quickly develop a compact description of the task, as well as information about the model's ultimate asymptotic performance when given effectively unlimited parameter updates. For most tasks, MDL compression tracks accuracy improvements closely (Figure 5). However, divergences between MDL and accuracy seen for Llama-3.2-IB on (RC-Challenge) provide diagnostic information: when accuracy improves without commensurate MDL compression, the model may be learning rather than eliciting.
(as
We can then recast our linettunig clicitation setting as a communication protocol between Alice and Bob:
All header terms are paid once, before the first label is transmitted, and the final summation term in the message is the usual prequential code computed only on the labels, as the inputs and backbone Mo are shared priori, following Perez al. [18].
Our MDL calculation proceeds follows:
23

---

Validation Accuracy vs Number Farameters
All Paints
Logietic
0.7
Vallazten Accustyy
0.5
Validation Accuracy vs Number of Parameters
Rumning Nax
Logistic fit
Validation Accunety
0.82
0.80
100
10a
10a
10"
Figure 11: Validation accuracy for all hyperparameter configurations for Llama 3.2 IB and Llama 3.2 3B fine-tuned on ARC-Easy, Each semi-transparent point indicates a fine-tuned model with a unique combination of hyperparameters and random seed. The logistic to the Pareto frontier denoted by solid blue line, and a gray dashed line connects the points that define the Pareto frontier. For both models, nearly all 250+ hyperparameter and seed combinations seeds with 50+ hyperparameter combinations each) for each parameter budget lie close to the Pareto frontier (within percentage points).
Initialization: Given parameter budget k, randomly select is parameters from LoRA adapters using seed
2. Hyperparameter selection: Through Bayesian optimization, identify hyperparameters h that maxi- mize validation accuracy
Prequential MDL computation: For the optimal (s, h) configuration, compute prequential loss during the first epoch only
Following the prequential MDL formulation [18, 32-34], we encode each example sequentially using the model trained only previously observed examples:
Gpeeq = - log P(D
Σ log (vv (ap; 0z-1),
(11)
in which t indexes gradient steps in the first epoch, ensuring cach encoded data point is unseen at encoding time. Practically, this is done by initializing the pretrained model, presenting each training example (or batch) exactly once, performing gradient step immediately after example (batch) has been seen, and accumulating per-example cross-entropy losses over examples (batches). This directly measures incremental compression efficiency of model during fine- tine-tuning.
Intuitive Interpretation: Consider MDL as measuring how efficiently model can "compress" its understanding of a task within its first pass over the training dataset. If updating merely 10 parameters enables the model to compress task labels by hundreds of bits within the first epoch alone, this suggests the model already possesses

---

Validation Accuracy vs Number Parameters
All Paints Logistic
0.7
Valldation Actunry
0.5
Validation Accuracy Number of Parameters
Running Max
Logidtic fit
0.84
8000
Wilderion Acc.nncy
0.82
0.80
109
10a
10a
10a
10a
10
10F
Validation Accuracy vs Number of Parameters
0.750
Rumning Nox.
Logistic fit
0.725
0.700
Velddetion Acuurety
0.650
0.625
0.600
0.75
30a
30
30
30*
30
Figure 12: Llama-3. 1-BB- fine-tuned on ARC-Challenge. Each semi- transpannnt point indicates fine-tuned model with a unique set of hyperparameters and random seed. The logistic fit to the Pareto frontier is denoted by solid blue line, and a gray dashed line connects the points that define the Pareto frontier.
25

---

Table 3: Casting PEFT elicitation Alice
Bob communication game.
Element
Description
Alice & Bob
Identical copies of pretrained base model Mo Base model Mo. learning algorithm A, dataset inputs (x1,
Shared knowledge
Alice's goal
Communicate datasct labels fyz, ... Un Bob
Communication (message)
(i) A one-shot header describing number of trainable parameters A: to initialize the LoRA adapters 02 with, parameter selection
seed hyperparameters h; + (ii) block-wise stream of label codes
Instructions for accessing capability/
adapter update A6, containing & learned weights that Bob obtains as he trains his copy of Mo
structured representation of the task-the the parameters merely serve as "key" to unlock this latent knowledge. Conversely, compression improves only marginally until thousands of parameters are modified, the capability may likely require learning from scratch rather than elicitation, as it cannot be casily unlocked or accessed.
Algorithm 1 Prequential MDL Computation.
Input: Base model Mo. dataset = { y4 IN parameter budget
Initialize model Mo with LoRA adapters with trainable parameters, Adk, (using seed s) Initialize MDL, Lj = for each batch B in epoch 1 do
Compute loss f = CrossEntropy (Manttrrpyyyyoooooooooa (A.,. B), labels(
LA += t x |B]
Update trainable parameters A6g via gradient descent
end for Return Lx
Interpretation for elicitation: In scenarios with high compression and low trainable parameter counts, the model rapidly develops an efficient encoding scheme with limited of locations where can make changes, suggesting leverages pre-existing structured representations. In scenarios with low compression, the model struggles to compress the label stream efficiently, indicating that the capability is not easily accessible or because it is absent. This differs from standard fine-tuning analysis because measure compression during initial learning, post-convergence, and explicitly account for the information of specifying which parameters to train. The resulting compression rate then reveals how much "latent structure" the model can immediately access.
The MDL compression Á& - z(k) therefore a direct, information theoretic measure of how helpful latent capability when parameters are available to specify how to access it. In the language of Alice and Bob, if granting Alice access to ff shortens the MDL. then f must convey information that was previously missing. The magnitude of the MDI. drop, measured in bits, quantifies the intrinsic value of the capability to the task.
In setting, every capability is presumed be latent in the pretrained (base) model Mo. A small adapter A with only & trainable weights serves as pointer to that capability: training enables model to develop this pointer. as A0, plays the role of invoking f. If short message (A0x) lets the model compress the subsequent label stream by hundreds of bits, it is highly probable that the original base model already contained highly structured representation of the task. Conversely, if the MDL shrinks slowly not at all until & becomes large, the capability was likely absent and must be learned rather than clicited.
J Data and Code Availability
GSM 8K- CoT-CCoiiiieoo dataset and evaluation scripts will be released with publication.
LoRA implementation with random masking
Bayesian optimization for ultra-low parameter regimes
MDL computation utilities
Frontier extraction and fitting procedures
26

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
The claims made accurately reflect paper's contributions and scope.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize other settings.
It is fine to include aspirational goals as motivation long it is clear that these goals are not attained by the paper.
2.
Limitations
Question:
Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification: We acknowledge several limitations of the scope of this rescarch, including task diversity, model selection, and effectiveness of our elicitation methods, in separate limitations section.
Guidelines:
The answer NA means that paper has no limitation while answer means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section their paper.
The paper should point out any strong assumptions and how robust results are violations these assumptions (e.g.. independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect the scope of the claims made, e.g., if the approach was only tested a few datasets with few runs. In general, empirical results often depend implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or speech-to-text system might not be used reliably to provide closed captions for online lectures because fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community, Reviewers will be specifically instructed to not penalize honesty concerning limitations.
grounds for rejection,
Theory assumptions and proofs
Question: For each thcoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
Justification: We do not include any theoretical results in this paper.
Guidelincs:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross-referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
27

---

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors encouraged to provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
Justification: We provide details on our fine-tuning details, including LoRA modules for adaptation, random parameter selection, hyperparameters, random seeds, and optimization methods.
Guidelines:
The answer NA means that the paper does not include experiments.
the paper includes experiments, No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example. if the contribution is novel architecture, describing the architecture fully might suffice, if the contribution is specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to hosted model (e.g., in the case of a large language model), releasing of model checkpoint, or other means that appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require all submissions provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily new algorithm, the paper should make it clear how reproduce that algorithm.
(b) If the contribution is primarily new model architecture, the paper should describe the architecture clearly and fully.
(c) the contribution a new model (e.g.. a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g.- with open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, which case authors are welcome to describe the particular way they provide for reprodueibility. In the case of closed-source source models, it may be that access to the model is limited in some way (c.g.. registered users), but it should be possible for other rescarchers have some path reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code. with sufficient instructions to faithfully reproduce the main experimental results, described in supplemental material?
Answer:
[No]
Justification: We plan to release our code once it has been anonymized. We try to provide sufficient instructions in the supplemental material to ensure that our results can be faithfully reproduced.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS ende and data submission guidelines (https: //n::://sppppp cc/p p i
gui des/ Mes//Coeeuul /CodeSubmi así onPol i cy) for more details.
While we encourage release of code and data, we understand that this might not possible, so "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g.. for a new open-soure benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https: /ntpssipp/...////// cc/ for more details.
28

---

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from script and why.
At submission time, preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code is permitted.
6. Experimental sefting/details
Question: Does the paper specify all the training and test details (c.g,, data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification:
We provide all train and test details in the supplemental material.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper to a level of detail that necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, or as supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate informa- tion about the statistical significance of the experiments?
Answer: [Yes]
Justification: We report bootstrapped 95% confidence intervals on all fits to data.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to library function, bootstrap, etc.)
The assumptions made should given (e-g., Normally distributed errors).
It should be clear whether the error bar is the standard deviation the standard error of the mean.
is OK report I-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error than state that they not verified.
CL, if the hypothesis of Normality of errors
asymmetric distributions, authors should be careful not show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates). crror bars are reported tables or plots, The authors should explain the text how they were calculated and reference the corresponding figures or tables in the text.
8. Experiments compute resources
Question: For each experiment, docs the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Answer: [Yes]
Justification:
We provide hardware information in the supplemental material.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs well estimate the total compute.
29

---

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary failed experiments that didn't 't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https : /ttp:///n/npp..eeee cc/ publ i c/Ethi csGui del ines?
Answer:
[Yes]
Justification: We have reviewed the NeurIPS Code of Ethies and believe our work adheres the listed principles.
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure preserve anonymity (e.g., if there is special consideration duc laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification: We discuss both potential positive and negative socictal impacts resulting from this work
in the Discussion section.
Guidelines:
The answer NA means that there is no socictal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious unintended uses (e.g.. disinformation, generating fake profiles, surveillance), fairness considerations (e-g., deploy- ment technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used generate deepfakes for disinformation. On the other hand, it not needed point out a generic algorithm optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used intended but gives incorrect results, and harms following from (intentional unintentional) misuse of the tcchnology.
there negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release models, providing defenses in addition to attacks, mechanisms monitor- ing misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible relcase of data or models that have a high risk for misuse (e.g. pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification: No models with dangerous capabilities will be released with this project. No dangerous datasets will be released.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use sual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines restrictions access the model implementing safety filters.
30

---

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors take this into account and make best faith effort.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (c.g., code, data, models), used in the paper, properly eredited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification; Asset creators are cited where relevant and licenses and terms use are described in the supplemental material.
Guidelines:
The answer NA means that the paper does existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset is used and, if possible, include URL.
The name of the license (e.g.. CC-BY 4.0) should be included for each asset. For scraped data from particular source (e.g., website), the copyright and terms of service of that source should provided.
assets are released, the license, copyright information, and terms of use the package should be provided. For popular datasets, paper ipperser thoode. com/ dstasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
If this information is not available online, the authors encouraged to reach out to the asset's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification: New assets are documented described the supplemental material. Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/model as part of their sub- missions via structured templates. This includes details about training, license, limitations,
The paper should discuss whether and how consent obtained from people whose asset used.
At submission time, remember to anonymize your assets (if applicable). can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and sereenshots, applicable, as well as details about compensation (if any)?
Answer: [NA]
Justification: This paper does not involve crowdsourcing human subjects.
Guidelincs:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.
According the NeurIPS Code of Ethics, workers involved in data collection, curation, other labor should be paid at least minimum wage in country of data collector.
15. Institutional review board (IRB) approvals equivalent for research with human subjects
31

---

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed the subjects, and whether Institutional Review Board (IRB) approvals (or equivalent approval/review based on requirements of your country or institution) were obtained?
Answer: [NA]
Justification:
This paper does not involve crowdsourcing or human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Depending on the country which research is conducted, approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applica- blc), such the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe usage of LLMs it important, original, or non standaadd component
core methods this research? Note that the LLM used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the rescarch, declaration is not required.
Answer: [NA]
Justification: This project does not use LLMs in important, original non-standard ways for its core methods.
Guidelines:
The NA means that the method development in this research does not involve LLMs as any important, original, or non-standard components.
Please refer I.M policy (https: //te:///eeuee ///ur//erii////////////// theurips.. ips wttpppp.c..eeeeeeeoe con ferences 2005// 2025/1.1M) for what should should not described.
32


Reviews:
[{"review_id": "XacSmYtSS9", "reviewer": "Reviewer_fDeD", "summary": "This paper investigates how latent capabilities in large language models (LLMs) can be “elicited” or activated through fine-tuning only a very small subset of the model’s parameters. The authors propose an information-constrained fine-tuning framework and define an “elicitation frontier,” which characterizes the trade-off between the number of trainable parameters and the model’s performance on a task.  In a series of experiments on five diverse tasks (including arithmetic reasoning, science question-answering, commonsense reading comprehension, and open-ended instruction following) using LLaMA-based models of 1B, 3B, and 8B parameters, they show that extremely few parameter updates can recover most of the performance gained by full fine-tuning. Beyond the empirical findings, the paper provides a theoretical interpretation using information theory and Minimum Description Length (MDL).", "questions": "please see the weakness part in the previous block. thank you", "limitations": "The authors include a limitation section.", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Strengths:\n\nThe paper provides an interesting perspective by examining parameter-efficient fine-tuning at an extreme scale. Instead of focusing on scaling up model size or data, it asks how minimally one can fine-tune a model to elicit capabilities.\n\nThe experimental evidence is compelling. Across multiple tasks (math word problems, science QA, commonsense reasoning) and for three model sizes, fine-tuning tiny random subsets of parameters yields surprisingly large performance gains.\n\nInteresting theoretical explanation\n\nWeakness:\n\nMy main concern is the evaluation. I am afraid that the finding is restricted to classification tasks. It is unclear why the author chooses the choice version of GSM8K but not the original GSM8K or even MATH, which is generally easy for current small models. \n\nBesides, although the authors mention the instruction tuning dataset Alpaca and show the results in the appendix, there are no details about the experiments on Alpaca and it is hard to understand what's going on there. What is the win rate you are computing against? What is the exact setting: e.g., are you fine-tuning on alpaca and evaluating on alpaca-eval?", "was_revised": true, "final_justification": "The rebuttal addresses some of my concern, and justifies why it is using MC version of gsm8k. I increase my score.", "rebuttal": "We thank Reviewer fDeD for the constructive feedback.\n\nBelow we clarify (i) the choice of evaluation tasks, (ii) why we began with the multiple‑choice variant of GSM8K, and (iii) the Alpaca experiments referenced in the appendix.\n\n### 1  Scope of evaluation beyond classification\n\nOur goal is to measure how many parameters must be tuned before a latent capability already present in pre‑training emerges. We therefore began with multiple‑choice tasks, which (a) isolate the model’s internal reasoning from generation quality and (b) allow inexpensive, fine‑grained sweeps over 50–100 hyper‑parameter settings × 5 seeds for each parameter budget which are used to build each elicitation frontier.\n\nGenerative tasks added since submission (no change to conclusions; full tables will appear in the camera‑ready appendix):\n* Lichess chess-puzzles: predict the optimal next chess move; accuracy measured by exact match on SAN tokens.\n* TinyStories‑v2: next‑token language modelling, evaluated by test‑set perplexity.\n* Qwen‑1.5 B & 32 B fine‑tuned on reasoning traces from the s1K dataset (a dataset of 1,000 problems with reasoning traces), evaluated on MATH500, AIME‑24, and GPQA‑Diamond, as in Muennighoff et al. (2025).\n\nAll three tasks exhibit the same logistic‑in‑log‑parameter scaling (tables and plots with corresponding results to be included in the camera‑ready). Example (Llama 3.2 1B on Lichess chess-puzzles):\n* 50% PGR (performance gap recovery between zero-shot and full fine-tuning) at ~100K parameters (≈27% exact optimal move accuracy)\n* 95% PGR at ~1M parameters (≈51% exact optimal move accuracy)\n* Only 0.1% accuracy with 10-shot prompting.\n\nTinyStories-v2, an easier task, matches the parameter counts seen for MC datasets, confirming that frontier position shifts with task difficulty and not output format.\n\nThese results strengthen the claim that the observed frontier is not an artifact of classification.\n\n### 2  Why the multiple‑choice (MC) version of GSM8K?\n\n**Controlling for “teaching” vs. elicitation.**\nThe base models tested (1 B–8 B) score <5 % zero‑shot on GSM8K (CoT) and 1B models remain below 40% even with 8 in‑context examples. Tuning on the full generative GSM8K risked learning new capabilities, confounding our goal of quantifying elicitation. The binary choice format raises the zero‑shot baseline to ~50 % and avoids the possibility that models learn new mathematical reasoning skills by training directly on the CoT traces in the original GSM8K dataset; instead, the models must predict the answer without being allowed to reason beforehand. This enables clear separation between latent‑skill activation and learning.\n\n**Computational cost.**\nEach frontier requires >2,000 fine‑tuning runs. Limiting loss/back‑prop to the answer token reduced wall‑clock time by ~40×, making the study feasible on available resources. After establishing the logistic pattern on MC tasks, we shifted additional compute to new domains (see §1 above) rather than re‑running GSM8K in generative mode.\n\n**Empirical consistency.**\nPreliminary experiments (not in the initial submission) on GSM8K (CoT) with the 8B model show the same sigmoidal curve, but shifted right (larger parameter budget). This supports the explanation above and will be reported in the final, camera-ready version.\n\n### 3  Alpaca fine‑tuning & win‑rate details\n\nYour interpretation is correct, we are fine-tuning on Alpaca and evaluating on Alpaca-Eval. The results included in the current draft examine the win rate against the base model without finetuning, which increases with the number of parameters trained. For example, Llama 3.2 1B improves from 80% to 88% win rate as the parameter budget grows from 10³ to 10⁵ (see Appendix B Figure 5c).\n\n### Outlook\n\nWe are currently extending the study to additional model families (Qwen) and to full‑generation GSM8K (CoT). We will incorporate these results, together with complete Alpaca hyperparameter details, in the camera‑ready version while keeping the core methodology unchanged.\n\nWe hope these clarifications address your concerns and demonstrate that the reported behaviour generalises beyond classification‑only settings. We appreciate your thoughtful review and are happy to discuss further during the discussion phase."}, {"review_id": "05I1oJyu9T", "reviewer": "Reviewer_yjAf", "summary": "The paper introduces a framework to measure how latent skills emerge in language models, defined by the smallest set of tunable parameters needed to reach certain task accuracies. They frame elicitation in two ways: (1) empirically, performance follows a logistic curve as more parameters are trained; (2) information-theoretically, the label stream’s MDL drops sharply once a latent skill is activated.", "questions": "1) Fix the typo \"of of\" on line 197. Add the caption in Figure 4\n\n2) What happens when a model that nails first-epoch loss by memorising noise still end up with a higher MDL than a slower, more compressible model? I am curious to know more about what the authors think about overfitting versus compression.\n\n3) Can the authors compute cumulative MDL across epochs? This can be Hyper-parameter agnostic and can help us to check overfitting.\n\n4) Can you test a wider range of tasks (e.g. benchmarks from this paper [1]) and other model family (e.g. Qwen) to see whether the same effect persists?\n\n\n[1] DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning", "limitations": "yes", "rating": 3, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths:\n\n1) The paper empirically shows only a fraction of parameters can be updated to elicit the latent capability of LLMS where performance rises logistically with the number of trained parameters.\n\n2) They also provide an information-theoretic view, where the Minimum Description Length (MDL) of the label stream falls as soon as a latent capability is unlocked.\n\nWeaknesses:\n\n1) The evaluations are done on narrow tasks domains and models, e.g. several multiple-choice reasoning and instruction-following tasks on Llama family of models. So, it's hard to conclude anything yet, whether these valuations will generalise across diverse tasks and model families.\n\n2) Information-theoretic analysis based on MDL relies on approximations such as first-epoch loss, which can be sensitive to hyper param choices like batch size, learning etc.\n\n3) It's not clear how these analyses translate into concrete steps for improving models or guiding better decisions.", "was_revised": false, "final_justification": "", "rebuttal": "We thank Reviewer yjAf for the thoughtful feedback and address each point in turn.\n\n### 1 Typo (“of of”) and missing caption (Fig. 4)\n\nWe thank the reviewer for pointing out these edits. Both have been corrected in our working draft and will be reflected in the camera‑ready version.\n\n### 2 First‑epoch MDL, memorization, and over‑fitting vs. compression\n\n**Why memorizing noise does not lower first‑epoch MDL.**\nPrequential MDL records the loss at the moment each example is first encountered; that loss is proportional to the codelength Alice must send to Bob before either of them has updated their model on that label. Because future noise labels are independent of past noise, memorization cannot reduce subsequent surprisal, so the cumulative codelength (and thus MDL) remains high.\n\n**Relationship to over‑fitting.**\nOver‑fitting arises in later epochs when the model re‑uses the same training examples. First‑epoch MDL is intentionally insensitive to this: it measures how quickly a fixed set of tunable parameters can be exploited to improve predictive performance, independent of eventual memorization. We therefore view first‑epoch MDL as complementary to final validation accuracy:\n* Validation accuracy frontier: _ultimate performance_ attainable with a given parameter budget.\n* First‑epoch MDL frontier: _facility_ with which the model reorients its existing representations; lower MDL ⇒ fewer bits required to communicate labels ⇒ the latent capability is easier to elicit.\n\nBoth frontiers are plotted over identical datasets and model backbones, so comparisons remain valid despite MDL’s linear growth with dataset size.\n\n### 3 Cumulative MDL and SDL as a hyperparameter‑agnostic alternative\n\nWe appreciate the reviewer's suggestion to consider training dynamics beyond the first epoch. We should clarify our terminology: MDL inherently measures the codelength for transmitting the dataset labels exactly once. After the first epoch, all labels have been transmitted, so traditional MDL doesn't extend to multiple epochs.\n\nThe reviewer's insight about hyperparameter dependence is valuable and motivates our use of Surplus Description Length (SDL). While prequential MDL captures first-epoch compression, SDL extends this to measure cumulative excess loss until convergence to a specified loss threshold is reached, regardless of the number of samples required to reach this threshold. This addresses the spirit of the reviewer's suggestion by providing a hyperparameter-agnostic metric that captures the full training trajectory.\n\nTo decouple elicitation speed from learning‑rate choice, we follow Whitney et al. (2021) and compute SDL:\n1. Choose a common loss threshold,  $\\varepsilon$ (constant across budgets/seeds).\n2. For each fine‑tuned run, accumulate the excess loss, $$\\text{SDL} = \\sum_{t=1}^{T} \\max\\bigl(\\ell_t - \\varepsilon , 0\\bigr),$$ until the running validation loss first falls below $\\varepsilon$.\n3. Define sample complexity as the number of unique training examples seen by that point.\n\nSDL integrates excess loss only up to the first step where validation loss falls below a common threshold  $\\varepsilon$; after that point, further samples contribute zero bits. SDL is (i) independent of total dataset size when $\\varepsilon$ is reached before the first epoch ends and (ii) less sensitive to learning rate, learning rate schedules, data order, or batch sizes than first-epoch MDL, providing a more hyperparameter-agnostic measure of elicitation speed. Runs that never cross $\\varepsilon$ within the first pass are assigned an infinite SDL, making the frontier visually diverge at budgets where elicitation becomes impossible for the selected loss threshold $\\varepsilon$. We verified that choosing $\\varepsilon$ anywhere between 25 % and 75 % of the full‑fine‑tune gain leaves the logistic shape unchanged. In our experiments, SDL reproduces the same sigmoidal trend observed in the first‑epoch MDL, with the SDL frontier decreasing as the tunable‑parameter budget increases. Full SDL curves and sample‑complexity plots will be included in the appendix.\n\n### 4 Broader task coverage and additional model families\n\nSince submission we have extended the study in two directions:\n\n1. Generative tasks: Lichess chess-puzzles (exact optimal-move accuracy) and TinyStories‑v2 (next‑token perplexity) using the same 1 B–8 B Llama backbones.\n2. Verification across model families: Qwen‑1.5 B and Qwen‑32 B fine‑tuned on chain‑of‑thought reasoning traces generated from the s1K dataset (Muennighoff et al. (2025)), evaluated on MATH500, AIME‑24, and GPQA‑Diamond.\n\nAll new experiments exhibit the same logistic relationship between performance and parameter budget, reinforcing the generality of the elicitation frontier. For instance, Llama 3.2 1B on Lichess chess-puzzles achieves 50% performance gap recovery at ~100K parameters and 95% at ~1M parameters, while TinyStories-v2 shows similar scaling at lower parameter counts due to its relative simplicity. We will present these results in the camera‑ready and make raw logs available.\n\n### Outlook\n\nWe plan to release complete MDL, SDL, and accuracy frontiers for every task‑model pair in the public appendix. The code for computing both MDL and SDL variants will be open‑sourced.\n\nThese additions require no changes to the core methodology or claims of the paper.\n\nWe hope these clarifications resolve the reviewer’s concerns and appreciate the opportunity to improve the manuscript."}, {"review_id": "vHPpMGx6Ni", "reviewer": "Reviewer_D3HX", "summary": "This paper introduces a new framework to quantify the elicitation of latent capabilities in large language models. The authors reframe elicitation as an information-constrained fine-tuning problem, where the core variable is not compute or data, but the number of trainable parameters. Their central methodology involves fine-tuning a very small, randomly selected subset of parameters within LoRA modules and measuring the resulting performance. Ultimately, the work proposes that the number of parameters required to unlock a skill is a fundamental measure of how \"latent\" that skill was, with implications for AI safety, evaluation, and understanding model internals.", "questions": "See Weaknesses", "limitations": "yes", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 4, "significance": 2, "originality": 2, "strengths_and_weaknesses": "> Strengths\n\n1. Framing elicitation as an information-constrained optimization problem is interesting.\n2. The findings in this paper, e.g.,  fine-tuning a tiny, randomly selected subset of parameters yields such significant performance gains are insightful. \n3. The paper is also well-written, with clear figures and a well-structured argument.\n\n> Weaknesses\n\n1. The evaluation in this paper is limited, as it only includes multiple-choice problems. Is it possible that the small number of parameters merely causes the model to memorize the format of its responses rather than actually improving its capabilities?\n\n2. I think it is very interesting to analyze across broader domains and plot which domains require more parameters. Is the number of parameters that need to be tuned related to the difficulty of the downstream tasks?\n\n3. The authors claim that knowledge is spread throughout the network rather than localized in specific layers. However, a well-known view is that knowledge is stored in the FFN parameters rather than in the attention parameters. A study on the roles of the FFN and attention parameters would make this work even more valuable.", "was_revised": false, "final_justification": "", "rebuttal": "We thank Reviewer D3HX for the detailed remarks and address each point below.\n\n### 1 Are the MC results due to memorizing output format?\n\n**Evaluation invariant to formatting.**\nFor every multiple-choice dataset, we score the model by directly comparing logits of the canonical answer tokens (e.g., “A”/”B”/”C”/”D”) at the final position. We additionally ran an ablation that sums probabilities over several token variations per option (including different capitalization, synonyms, whitespace). The two procedures differ by <0.2 percentage points on average, showing that format memorization does not explain the gains.\n\n**Fine‑tuning vs. in‑context learning.**\nWith identical logit scoring, 10‑shot prompting improves the Llama 3.2 1B backbone on ARC‑Easy from 25% → 30%, whereas tuning only ~1K parameters raises accuracy to 65%. The large gap indicates that extra parameters unlock a latent skill rather than merely encoding the token template.\n\n**Generative control tasks.**\nPost‑submission, we replicated the experiment on (i) Lichess chess-puzzles (exact optimal‑move generation) and (ii) TinyStories‑v2 (next‑token perplexity). Both tasks follow the same logistic elicitation curve, ruling out MC‑specific artifacts. For Llama 3.2 1B on Lichess chess-puzzles, 50% performance gap recovery occurs at ~100K parameters and 95% performance gap recovery occurs at ~1M parameters; TinyStories-v2 shows similar scaling but with the frontier shifted to the left at trainable parameter budgets comparable to the MC datasets, reflecting the relative simplicity of the task. Full tables will appear in the camera‑ready.\n\n### 2 Relation between task difficulty and parameters required\n\nAcross all datasets, we observe a strong monotonic trend: more challenging tasks (lower zero‑shot and full‑FT performance) require a larger parameter budget to reach 95 % of the full‑fine‑tune gain. For example,\n* ARC‑Challenge (Llama 3.2 1B): base ≈ 24 %, full‑FT ≈ 54 %; 95 %‑gap closeure at ~200K tunable parameters.\n* ARC‑Easy (Llama 3.2 1B): base ≈ 25 %, full‑FT ≈ 76 %; same 95 %‑gap closure threshold met at ~5K parameters.\n\nSimilar patterns hold in the new generative tasks where Llama 3.2 1B needs ~100K parameters to cross 50 % performance gap recovery (PGR) on Lichess chess-puzzles. This supports the reviewer’s intuition that elicitation cost tracks intrinsic task difficulty.\n\n### 3 FFN vs. Attention parameters\n\nWe have performed ablations targeting different components of the transformer block, in which we compare the performance of adapting only the self-attention layers of the transformer block (_K, Q, V, O_ matrices), only the FFN layers (_G, U, D_ matrices), the entire transformer block (all matrices _K, Q, V, O, G, U, D_), only the _Q_ and _V_ matrices, only _K, Q, V_ matrices, only _K, Q, V, G, U_ matrices, and the same set of randomly selected matrices in each transformer block layer. \n\nWe find that attention-only tuning (_K, Q, V, O_ matrices) is consistently the most parameter‑efficient across the four multiple choice datasets. This suggests that the information needed to activate the reasoning skill is not confined to the FFN subspace. A full layer‑type analysis will be added to Appendix C.1; a deeper interpretability study is outside the scope of the present work, but we agree it would be valuable future work.\n\n### 4 Broader domain coverage\n\nBeyond the classification benchmarks in the submission, we now include:\n1. Reasoning: Qwen‑1.5 B and 32 B fine‑tuned on reasoning traces and evaluated on MATH500, AIME‑24, and GPQA‑Diamond, following the procedure of Muennighoff et al. (2025).\n2. Chess puzzles & story generation: see §1 above.\n\nAll new curves exhibit the same parameter/accuracy logistic, reinforcing the generality of the elicitation‑frontier concept. These results will appear in the appendix; no change to the main claims is required.\n\n### Summary\n\nThe additional analyses confirm that (i) the effect is not an artifact of response formatting, (ii) harder tasks demand more tunable parameters, and (iii) attention layers are at least as important as FFNs for elicitation. We appreciate the reviewer’s suggestions and believe the forthcoming appendix expansions will address these concerns."}, {"review_id": "bRjm3A6y1o", "reviewer": "Reviewer_jyH6", "summary": "This paper introduces an empirical and theoretical framework to quantify elicitation of latent capabilities in LLMs. The authors propose elicitation frontiers, which curves mapping the number of randomly trained parameters to accuracy improvements on downstream tasks. They find that training as few as 10–100 random parameters can recover over 50% of the performance gap between zero-shot and fully fine-tuned models, and a few thousand parameters can close up to 95% of the gap. They also introduce an information-theoretic lens using MDL to distinguish elicitation from teaching. They empirically validate their framework across multiple LLM sizes and tasks.", "questions": "1. Is there a practical way to determine which latent capabilities exist, or is this inherently empirical?\n2. Could model pruning, or structural sparsity methods improve over random parameter selection in elicitation?", "limitations": "The authors thoughtfully acknowledge limitations, including limited generalization to other tasks and architectures, relying on first-epoch loss using prequential coding of MDL, the possible existence of more efficient elicitation methods.", "rating": 4, "confidence": 2, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 2, "significance": 3, "originality": 3, "strengths_and_weaknesses": "## Quality\n### Strengths:\n- The paper conducts extensive empirical evaluation across models with various sizes and multiple tasks.\n- The study demonstrates rigorous in methodology, including aspects of controlled PEFT experiments, random parameter sampling, MDL analysis, and detailed tuning process.\n\n### Weaknesses:\n- MDL analysis relies on first-epoch loss approximations, which may be insufficient in robustness (as stated in Section 6.3).\n- Experiments are very limited to Llama series models. It has not been validated on other series of models, which may raise concerns about the generalizability of the proposed assumption to different model architectures.\n\n\n## Clarity\n### Strengths:\n- The core idea of the paper in terms of elicitation vs. teaching is illustrated clearly.\n- The figures of logistic fit curves and MDL/accuracy plots provide effective visualizations.\n\n### Weaknesses:\n- While the paper revolves around the concepts of \"latent capabilities\" and \"elicitation\", it never provides a precise and formal definition of what constitutes a latent capability, and what exactly the elicitation is that can demonstrate a model's capability. Though the concepts and the distinction between them are more inferred through empirical behaviors, but readers may struggle to understand the conceptual boundary.\n- There are several terms such as \"Pareto frontier\", \"logistic-in-log-parameter scaling\", and \"prequential coding\", that are used without intuitive explanations, which makes the empirical results in Section 4 difficult to be followed. It would be better to add the core intuition behind these terms before using them directly in the results.\n- The paper has missing content, particularly in the appendix. Sections A, B, F, and G are empty, which gives the impression that the paper is incomplete.\n\n## Significance\n### Strengths:\n- The paper provides a novel way to estimate ceiling performance of pretrained models, with important implications for model safety and auditing.\n\n### Weaknesses:\n- While the paper proposes MDL as a diagnostic tool, practical use cases for MDL estimation in real-world evaluations are not demonstrated.\n- Though the proposed elicitation perspective is intuitively important in addressing safety risk, the paper does not discuss how elicitation frontiers might integrate with fine-tuning under safety constraints. For instance, how to avoid eliciting harmful capabilities while tuning the models.\n\n## Originality\n### Strengths:\n- The paper seems to be the first to systematically connect random-parameter PEFT with MDL compression to study latent capabilities.\n- The paper introduces the concept of an “elicitation frontier” as a complementary framework to classic scaling laws.\n\n### Weaknesses:\n- Technically, the paper does not propose a new training method or elicitation algorithm/mechanism. The parameter selection is purely random, and all training follows standard LoRA PEFT. Thus, the methodological contribution is more interpretive than technical.\n- The paper suggests that capabilities are distributed across parameters. Though this is a well-established hypothesis in LLM interpretability and representation learning, the paper does not further provide methods to localize or analyze where specific capabilities locate within the model.", "was_revised": true, "final_justification": "The explanations have clarified some of my concerns, particularly regarding certain key concepts and model safety in application scenarios. However, more rigorous analysis is still needed in areas such as parameter selection. Therefore, I will maintain my current score.", "rebuttal": "We appreciate Reviewer jyH6’s detailed feedback and address each comment below.\n\n### 1 Conceptual clarity: latent capability, elicitation, key terms\n\n* **Latent capability.**  We define it as _a capability $f$ is latent in model $M$ if $M$ can achieve significantly above-random performance on tasks requiring f after minimal parameter updates, despite poor zero-shot performance._\n* **Elicitation.**  Given a latent capability, elicitation is any parameter‑efficient intervention that raises performance above a specified threshold without adding new capabilities.\n* **Pareto frontier.**  Set of (parameter p, accuracy a) points for which no other configuration attains ≥ a with ≤ p.\n* **Logistic‑in‑log‑parameter scaling.**  Empirical observation that accuracy vs. $\\log_{10}(\\text{parameter budget})$ fits a logistic curve.\n* **Prequential coding (MDL).**  Cumulative cross‑entropy on each example the first time it is seen; equivalent to online MDL codelength.\n\nWe will insert these formal definitions prior to the start of §4 in the main text in the camera‑ready.\n\nWe apologize for the confusion regarding the appendix sections. Due to NeurIPS's submission timeline, the main paper was submitted first with placeholder appendix sections (A, B, F, G), while the complete supplementary materials were uploaded during the designated supplementary material submission period one week later. All sections referenced in the paper have been fully populated in the supplementary materials, including complete experimental protocols (Appendix A), additional baselines (Appendix B), model comparison results (Appendix F), and statistical analyses (Appendix G). We understand the reviewer may have only accessed the initial submission PDF. All sections referenced in the paper have been fully populated in the supplementary materials.\n\n### 2 Robustness of first‑epoch MDL approximation\n\nTo test sensitivity, we sample the top 5 performing runs for each seed and compute MDL for each of these runs. The resulting MDL frontiers differ by ≤ 2 % at all budgets. In addition, we compute Surplus Description Length (SDL) with a common threshold $\\varepsilon$; SDL is far less sensitive to optimizer hyperparameters and reproduces the same logistic behavior. These results strengthen confidence that first‑epoch MDL is a reliable proxy for elicitation speed.\n\n### 3 Generalizability beyond Llama models\n\nSince submission, we have expanded our task and model coverage to include generative reasoning tasks on Qwen‑1.5 B and Qwen‑32 B.  All three show sigmoid frontiers on MATH500, AIME24, and GPQA Diamond. We will include the curves in a new appendix section, Appendix K; no change to the main text claims is required.\n\n### 4 Practical use cases for model safety & auditing\n\n1. **Elicitation vs. teaching.**  MDL/SDL provide an “information budget” view: if a fine‑tune requires > K bits to achieve the 95% frontier expected for the model size, auditors can flag that the run is likely teaching a new skill rather than eliciting an existing one.\n2. **Fine-tuning API budgeting.**  Regulators can bound the number of tunable parameters accessible to third‑party plug‑in developers; our frontier tells them how much accuracy gain that budget could plausibly unlock.\n3. **Practical evaluation setting.**  Safety auditors often fine‑tune a small head layer to probe hidden skills. Our results show that training ≤ 10 K random parameters cannot introduce a complex new skill in a 1B model but can reliably elicit existing ones (see Fig. 3).  Therefore, auditors can cap the parameter budget and be confident they are measuring, not teaching.\n\nWe will add a concise discussion of these applications to §6.2 of the main text (practical and safety implications).\n\n### 5 Practical discovery of latent capabilities\n\nFully automatic enumeration and detection of capabilities is beyond current technique, but two complementary paths exist:\n1. **Empirical probes and capability evaluations:** use elicitation frontiers on diverse tasks (as in our study) to map where latent abilities saturate.\n2. **Mechanistic interpretability:** neuron‑level analyses that identify features corresponding to a capability\nWe see our framework as providing the cost axis that such feature‑discovery methods can relate to.\n\n### 6 Random parameter selection vs. pruning/structured sparsity\n\nWe agree that structured selection can be more parameter‑efficient in principle. However, our goal is to measure total information required, including any search cost. Random subsets have zero selection information and therefore give a clean, reproducible upper bound on elicitation cost. §6.3 of the paper now incorporates a discussion of how future work could incorporate pruning by adding the bits needed to index the selected parameters (≈ $\\log_2 \\binom{P}{k}$) to the information budget.\n\n### 7 Minor points\nOur goal is to measure elicitation, not propose a new optimizer.  Using an off‑the‑shelf PEFT method (LoRA) guarantees that the observed behavior stems from the parameter budget itself.  The methodological novelty lies in (i) framing elicitation as an information‑constrained optimization problem, (ii) deriving and empirically validating a logistic frontier, and (iii) tying that frontier to MDL/SDL.\n\nWe agree localization would be valuable future work. Our objective in this paper is different: we isolate how much information is required to unlock a capability, irrespective of where that information resides. Once an information budget is established, existing localization tools (e.g., causal tracing, sparse probing) can operate within that budget. We will clarify this scope in §6.1 of the main text.\n\n### Summary\n\nWe provide clearer definitions, robustness checks for MDL, cross‑model confirmation, and concrete safety applications. We hope these additions resolve the reviewer’s concerns and appreciate the insightful suggestions."}]

Author rebuttal:

Meta-review: This paper reframes elicitation as an information-constrained fine-tuning problem and advances the notion of "elicitation frontier" as a logistic relationship between trained-parameter budget and recovered performance gap. The link to first-epoch prequential MDL gives the empirical regularity a principled lens and a practical way to separate elicitation from teaching. Post-rebuttal evidence strengthens the claim beyond multiple-choice, since the authors add generative tasks and a second model family (Qwen) that exhibit the same curve. Besides, they justify GSM8K-MC for feasibility and isolation and provide layer-type ablations showing attention-only updates are especially parameter-efficient.

For the next revision, I recommend bringing the generative and Qwen results into the main text rather than the appendix, introducing SDL alongside MDL with a brief explanation of its hyperparameter robustness, adding the layer-ablation summary and the Alpaca setup and additionally reporting variability on the frontiers. A short discussion contrasting random selection with a simple structured choice would round out concerns about parameter selection. With those changes the paper would be stronger with reproducible empirical findings and clear downstream value for evaluation and safety policy.
Decision: Accept (poster)