Forecasting Downstream Performance of LLMs With Proxy Metrics
Abstract: Progress in LLM development is often driven by comparative decisions: which architecture to adopt, which pretraining corpus to use, or which training recipe to apply. Making these decisions well requires reliable performance forecasts, yet the two commonly used signals are fundamentally limited. Cross-entropy loss is poorly aligned with downstream capabilities, and direct downstream evaluation is expensive, sparse, and often uninformative at early training stages. Instead, we propose to construct proxy metrics by aggregating token-level statistics, such as entropy, top-k accuracy, and expert token rank, from a candidate model's next token distribution over expert-written solutions. Across three settings, our proxies consistently outperform loss- and compute-based baselines: 1) For cross-family model selection, they rank a heterogeneous population of reasoning models with mean Spearman Rho = 0.81 (vs. Rho = 0.36 for cross-entropy loss); 2) For pretraining data selection, they reliably rank 25 candidate corpora for a target model at roughly $10{,}000\times$ less compute than direct evaluation, pushing the Pareto frontier beyond existing methods; and 3) for training-time forecasting, they extrapolate downstream accuracy across an $18\times$ compute horizon with roughly half the error of existing alternatives. Together, these results suggest that expert trajectories are a broadly useful source of signal for assessing model capabilities, enabling reliable performance forecasting throughout the model development life cycle.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Overview
This paper is about a simple, cheap way to guess how well a LLM will do on real tasks—like tricky math problems or coding challenges—without having to run full, expensive tests. Instead of asking the model to solve the whole problem, the authors “peek” at how the model predicts each small step in an expert’s solution and turn those predictions into easy-to-compute scores called proxy metrics.
What questions did the researchers ask?
They focused on three practical questions that come up when building or choosing LLMs:
- Given several different models, which one will do best on a tough task?
- Given many possible training datasets, which ones are worth investing in for a big, expensive training run?
- During training, can we forecast how good the model will be at the end, based on early progress?
How did they do it? (Methods explained simply)
Think of watching a chess master play and trying to predict their next move at each moment. Even if you can’t play like the master yet, being able to anticipate their moves is a good sign you understand what’s going on.
The authors use the same idea for LLMs:
- Get expert solutions: They collect step-by-step solutions (reasoning “trajectories”) written by strong models or humans for tasks like math and coding.
- Run a quick check: For each step (token) in an expert solution, they ask the candidate model, “What do you think the next token will be?” The model doesn’t have to generate a solution—just give its next-token probabilities. This is a single, very fast pass.
- Turn predictions into simple scores (proxy metrics): They compute small statistics from those predictions, such as:
- Is the expert’s next token among the model’s top guesses? (top-k accuracy)
- How confident is the model? (entropy = more uncertainty means less confidence)
- Where does the expert’s token rank among all the model’s guesses? (rank)
- Weight the important steps more: Not every token matters equally. They give extra weight to informative positions, like rare tokens or moments when the model is most unsure—similar to paying more attention to “forks in the road” where the reasoning could go multiple ways.
Finally, they average these scores across many steps and problems to get a small set of numbers that summarize how well the model “tracks” expert reasoning. These are the proxy metrics.
What did they find, and why does it matter?
The authors tested their approach in three real-world situations:
- Picking the best model across different families
- Goal: Rank many different models (small to large, trained in different ways) on hard reasoning benchmarks without running full evaluations.
- Result: Their proxies ranked models very close to their true performance (average Spearman ρ ≈ 0.81, where 1.0 is perfect rank agreement). A common baseline—cross-entropy loss on generic text, which is like “how surprised the model is by everyday sentences”—did much worse (ρ ≈ 0.36).
- Why it matters: You can choose the best model for a task quickly and cheaply, even when full evaluations are costly or unavailable.
- Choosing training data with tiny, cheap runs
- Goal: From 25 possible training datasets, pick the ones that will work best for a much bigger (1B-parameter) model—without paying the huge cost of training at that scale.
- Result: Using proxy metrics computed with very small models (as little as ~10,000× less compute than the big run), they could correctly recover the dataset ranking with high accuracy, outperforming previous methods that needed more information.
- Why it matters: Teams can make smarter, cheaper choices about what data to train on before spending millions on a full-scale run.
- Forecasting future performance during training
- Goal: Predict how well a model will perform later in training using only early checkpoints.
- Result: The proxy metrics change smoothly and predictably over time (following simple curves), and they let the authors forecast final accuracy more accurately—about half the error of common alternatives that use loss or compute alone—across an ~18× training-compute gap.
- Why it matters: You can decide earlier whether to continue training, change course, or stop, saving time and money.
In short: these tiny, step-by-step “shadow tests” over expert solutions gave strong, early signals about real task performance—signals that were both cheap and reliable.
Why this is useful
- Saves compute and money: You don’t need to generate full solutions or run expensive evaluations. A single pass over expert solutions is enough.
- Works even when models are weak: Small or early-stage models might not get final answers right, but they can still “sense” the right next steps. That’s a valuable signal when normal accuracy is near zero.
- Flexible expert sources: You only need the expert’s tokens (text), not hidden numbers like expert probabilities. That means you can use strong closed models or humans as the expert source.
- Practical decisions across the lifecycle: Helps pick models, choose datasets, and forecast training outcomes—three decisions that drive time and cost in LLM development.
A few caveats to keep in mind
- Not one metric to rule them all: Different tasks may prefer different proxy combinations. The authors often combine a few simple metrics for best results.
- Tested scopes: Many experiments focus on reasoning tasks and certain model families or checkpoints (e.g., OLMo-3-7B). More testing is needed for other task types (like long-context or open-ended writing) and other architectures (like mixture-of-experts).
- Quality of experts matters: If expert solutions are noisy or low quality, the signal may weaken. Understanding this trade-off is important for real deployments.
Bottom line
By “listening in” on how a model predicts each step of an expert’s solution, we can build quick, cheap scores that strongly relate to real performance. These proxy metrics help teams choose better models and data, and forecast training outcomes earlier—saving time, money, and compute while still aiming at what really counts: doing well on the target task.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a single, concrete list of what remains missing, uncertain, or unexplored, framed so future researchers can act on it.
- Generalization across architectures and scales: Validate whether proxy metrics and power‑law extrapolations hold for mixture‑of‑experts (MoE), larger/smaller scales, alternative base architectures, and different post‑training recipes (e.g., RLHF/DPO with sharp distribution shifts).
- Task breadth beyond reasoning and MCQ: Test on long‑context retrieval, tool‑use/agentic evaluations, open‑ended generation (e.g., summarization, translation), code execution with complex toolchains, and multilingual tasks to assess transfer of proxy predictiveness.
- Extrapolation under training regime changes: Measure proxy smoothness and predictiveness across optimizer changes, curriculum shifts, domain shifts, and post‑training phases where loss dynamics are non‑smooth or non‑stationary.
- Dependence on expert trajectory quality: Quantify how ranking/extrapolation degrades with weaker, noisy, or partially incorrect experts; determine minimal expert strength/coverage needed to retain performance; characterize sensitivity to the fraction of incorrect expert solutions.
- Expert style and formatting sensitivity: Evaluate robustness to differences in chain‑of‑thought style (verbosity, formatting, tokenization conventions), prompt templates, and languages; test with multiple human and model experts to estimate variance and bias.
- Necessity and cost of expert traces: Assess feasibility and cost to obtain high‑quality traces at scale in domains without strong LLMs; benchmark compute and human time needed per task to reach target accuracy/decision thresholds.
- Closed‑API candidate models: Many APIs restrict access to full logprobs; study how proxy quality degrades if only top‑k, sampled tokens, or partial probability mass is available; investigate approximations (e.g., calibrated sampling) for black‑box candidates.
- Tokenizer and vocabulary dependence: Metrics like entropy, rank, and frequency are tokenizer‑dependent; develop and test tokenizer‑invariant normalizations and evaluate cross‑tokenizer robustness in cross‑family rankings.
- Position weighting design: The paper uses only the last 1,000 tokens; ablate position windows (early/middle/late), adaptive token selection (e.g., dynamic “forking tokens”), and task‑specific weighting schemes to identify generalizable choices.
- Metric library completeness: Systematically explore beyond the 80 predefined proxies (e.g., calibration errors, KL to expert, mode mass on expert’s top‑k set, margin over semantic units) and learn aggregation functions end‑to‑end; compare against the current hand‑crafted set.
- Risk of Goodhart’s law: If proxies become optimization targets, models may “game” them without real capability gains; design adversarial tests and auditing procedures that detect proxy inflation and evaluate causal impact on downstream performance.
- Mapping proxy→accuracy reliability: Provide uncertainty quantification (prediction intervals, calibration curves) for proxy‑to‑accuracy fits; identify tasks where monotonicity breaks and characterize conditions under which mappings remain stable.
- Pretraining data selection for reasoning: Replicate DataDecide‑style experiments on reasoning benchmarks (math, science, code) rather than only OLMES MCQ, and test whether the same univariate proxies remain Pareto‑optimal.
- Cross‑domain transfer of proxies: Evaluate whether proxies computed on expert traces from one domain predict model rankings in a different domain where expert traces are scarce; quantify transfer gaps and needed adaptation.
- Multiple‑expert aggregation: Study how many and which experts are needed (diversity vs. strength trade‑offs), and compare simple averaging to learned weighting across experts; measure variance reduction vs. cost.
- Handling answer tokens and leakage: Analyze how inclusion/exclusion of final answer tokens affects proxies; develop protocols to prevent direct answer leakage while retaining informative reasoning tokens.
- Sequence length normalization: Develop and test length‑robust normalizers so scores are comparable across traces of varying lengths; measure the effect of extreme trace length variability on rankings.
- Robustness to adversarial/noisy traces: Stress‑test proxies with perturbed or adversarially edited expert trajectories (e.g., spurious steps, reordered reasoning) to determine failure modes and design robust variants.
- Practical compute profiling: Provide detailed wall‑clock and memory profiles for computing proxies on large candidate/model/task grids; identify bottlenecks and scalable batching/streaming strategies for frontier‑scale settings.
- Black‑box expert sources: Demonstrate data selection and model ranking when expert probabilities are unavailable and experts are closed‑weight or human; quantify how human‑only traces compare to frontier LLM traces.
- Theoretical grounding: Develop formal analysis linking token‑level agreement/uncertainty along expert trajectories to downstream accuracy under simplified assumptions (e.g., probabilistic process models), clarifying when proxies are sufficient statistics for ranking.
- Cross‑validation and selection stability: Conduct sensitivity analyses on the inner‑split fraction, model subsampling, and training window size; report instability modes and propose more stable selection strategies (e.g., nested CV, Bayesian model averaging).
- Fairness and domain bias: Investigate whether proxies amplify expert or benchmark biases (domain, demographic, linguistic), and propose de‑biasing schemes (e.g., reweighting by content attributes) where needed.
- Extension to multimodal models: Adapt and test the approach for VLMs and speech‑text models using expert traces across modalities (e.g., vision chain‑of‑thought, tool‑grounded reasoning), including modality‑specific token importance schemes.
- Open‑source reproducibility: Release ablations on larger, more diverse model sets and multiple training runs per model to separate signal from run‑to‑run noise; report statistical power for the observed Spearman/decision‑accuracy gains.
Practical Applications
Immediate Applications
- Cross-family model selection without full downstream evals – sectors: software, education, robotics, finance, healthcare
- Tools/products/workflows: “proxy-metrics scorer” that ranks candidate LLMs for a target task using expert-written solutions and a single forward pass; model procurement dashboards that show proxy score vs. benchmark accuracy confidence bands.
- Why useful: Achieves strong rank correlation with true downstream accuracy (mean Spearman ρ ≈ 0.81 vs. 0.36 for CE loss), even when benchmarks are expensive or produce near-chance scores for small/intermediate models.
- Assumptions/dependencies: Access to high-quality expert trajectories for the target task; ability to obtain the candidate model’s next-token probabilities/logprobs (forward pass); results established on reasoning tasks.
- Low-cost pretraining data selection and mixture triage – sectors: foundation model training, data platforms
- Tools/products/workflows: “dataset triage” service that trains 4M–90M proxy models per corpus and ranks corpora via univariate proxy metrics; mixture search tools that surface top datasets at ~10⁻⁵ of target compute.
- Why useful: Matches or exceeds downstream-eval baselines while using ~10,000× less compute; requires only expert tokens (not expert logprobs), enabling use of closed-weight experts or human-written traces.
- Assumptions/dependencies: Proxy models trained on candidate corpora; expert CoTs for the target evaluation distribution; validated on OLMES multiple-choice tasks (not yet on hard reasoning for this use case).
- Training-time forecasting and budget planning – sectors: MLOps, cloud/compute scheduling, R&D
- Tools/products/workflows: “learning curve forecaster” that fits power laws to proxy metrics from early checkpoints and predicts end-of-training accuracy; early-stop/continue gates based on projected ROI.
- Why useful: Proxy-to-accuracy fits extrapolate across ~18× compute horizons with ~½ the error of loss- or compute-based fits.
- Assumptions/dependencies: Smooth proxy evolution along training; access to early checkpoints; demonstrated on OLMo-3-7B (generalization to other scales/architectures is plausible but unproven).
- Benchmarkless A/B testing for feature teams – sectors: product engineering, small/medium enterprises
- Tools/products/workflows: Use a small set of expert solutions for your task to rank API-accessible models when sandbox environments or evaluators are unavailable.
- Why useful: Reduces latency and cost of model choice where direct, high-fidelity evaluation (e.g., code execution, human grading) is infeasible.
- Assumptions/dependencies: API must expose token logprobs or calibrated top-k; expert steps representative of intended usage.
- Post-training recipe comparison (e.g., SFT vs. RLHF variants) – sectors: applied AI, platform teams
- Tools/products/workflows: Rapidly compare post-training variants by proxy scores on expert traces of target tasks; select the recipe with best predicted downstream performance before expensive evals.
- Why useful: Differentiates methods even when task accuracy is flat at early stages.
- Assumptions/dependencies: Comparable tokenization and decoding vocabulary across variants; consistent expert traces.
- Focused supervision and data curation via “forking tokens” – sectors: RLHF/RLAIF, data engineering
- Tools/products/workflows: Identify tokens with high entropy/low expert agreement and upweight them in preference training or data collection; mine training examples that maximize proxy signal.
- Why useful: Proxies emphasize uncertain/rare positions that drive learning; aligns with observed training signal concentration on high-entropy “forks.”
- Assumptions/dependencies: Ability to modify weighting in training loops; care to avoid overfitting proxy artifacts.
- Rapid capability monitoring and drift detection – sectors: safety, compliance, reliability engineering
- Tools/products/workflows: Periodic proxy scoring on a fixed expert corpus to detect capability regressions or unexpected jumps without running full eval suites.
- Why useful: Dense, task-conditioned signal in a single forward pass provides sensitive early warnings.
- Assumptions/dependencies: Stable expert set; monitoring thresholds calibrated to proxy variance.
- Vendor-neutral evaluation when target environments are inaccessible – sectors: enterprises with restricted/regulated data
- Tools/products/workflows: Use sanitized expert traces reflecting proprietary workflows to rank external LLMs while keeping environments and data closed.
- Why useful: Reduces compliance overhead relative to full-on environment-dependent benchmarking.
- Assumptions/dependencies: High-fidelity “stand-in” experts that reflect the real task; access to model logprobs.
- Academic experiments on scaling laws and curricula – sectors: academia
- Tools/products/workflows: Replace many expensive downstream runs with proxy-based measurements to study model families, data curricula, and optimization recipes across seeds and scales.
- Why useful: Higher experimental throughput with better task alignment than generic CE loss.
- Assumptions/dependencies: Expert trace availability; explicit reporting of proxy selection and held-out tasks to avoid post-hoc bias.
- Procurement and policy reporting “lightweight capability statements” – sectors: public sector, finance, healthcare
- Tools/products/workflows: Attach proxy-based capability summaries to model RFPs or regulatory submissions when full external evaluations are impractical.
- Why useful: Provides standardized, low-cost, task-conditioned evidence of capability.
- Assumptions/dependencies: Agreement on reference expert sets; transparency about selection criteria and known limitations.
- Startup/individual developer model selection for apps – sectors: daily life/product dev
- Tools/products/workflows: Collect a dozen expert step-by-step exemplars of your task and run the proxy scorer across affordable API models to choose the best fit.
- Why useful: Avoids costly, noisy “build full eval first” loops for early-stage teams.
- Assumptions/dependencies: APIs exposing sufficient probability information; representative exemplars.
Long-Term Applications
- Regulatory standards and audits built on proxy protocols – sectors: policy, safety, critical infrastructure
- Tools/products/workflows: Formalize proxy scoring suites with trace provenance, stability checks, and uncertainty estimates to support pre-deployment capability assessments under AI governance frameworks.
- Why promising: Task-conditioned, compute-light metrics are easier to scale across organizations than full bespoke evals.
- Assumptions/dependencies: Standardized expert trace repositories; third-party oversight; robustness against gaming/Goodharting.
- Generalization to non-reasoning and agentic tasks – sectors: agents, long-context retrieval, creative generation
- Tools/products/workflows: Extend proxies to multi-turn agent trajectories, tool-use logs, and long-context reading comprehension with structure-aware token importance weighting.
- Why promising: Same “dense, task-conditioned” intuition should carry over if trajectory quality is high.
- Assumptions/dependencies: High-quality agent traces; revised metrics for tool calls, function arguments, and long-range dependencies; empirical validation.
- Online training controllers that adapt using proxy signals – sectors: foundation model training, MLOps
- Tools/products/workflows: Closed-loop schedulers that adjust learning rates, data mixtures, and checkpoint cadence based on proxy trends and predicted downstream targets.
- Why promising: Better sample and compute efficiency by targeting high-signal regions of data/task space.
- Assumptions/dependencies: Stable proxy-to-performance mapping during training; safeguards against instability.
- Data marketplaces ranked by predicted task value – sectors: data economy
- Tools/products/workflows: Marketplace listings advertise proxy-based task value for each corpus across common capability suites, helping buyers compose mixtures without massive trials.
- Why promising: Aligns incentives toward high-yield, task-relevant data.
- Assumptions/dependencies: Trusted third-party proxy evaluations; metadata standards; anti-gaming measures.
- Automated expert-trace generation with human-in-the-loop verification – sectors: specialized domains (biomed, law, finance)
- Tools/products/workflows: Frontier models produce draft traces; domain experts verify and enrich them; the proxy scorer ranks models/datasets in highly specialized tasks.
- Why promising: Scales expert signal into domains where benchmarks are rare.
- Assumptions/dependencies: Expert availability; quality control; privacy/security for sensitive traces.
- Safety gating and capability caps informed by proxy forecasts – sectors: safety, deployment governance
- Tools/products/workflows: Use proxy-extrapolated capabilities to set staged release gates or activate guardrails before capability thresholds are crossed.
- Why promising: Earlier, more reliable warning signals than generic loss/compute curves.
- Assumptions/dependencies: Clear risk thresholds tied to proxy levels; periodic recalibration with ground-truth evals.
- Curriculum and objective design targeting high-signal tokens – sectors: optimization research
- Tools/products/workflows: Train objectives that explicitly emphasize “forking tokens” or disagreement regions identified by proxies; design curricula that escalate proxy difficulty.
- Why promising: Could accelerate learning on reasoning-heavy tasks.
- Assumptions/dependencies: Avoiding over-optimization on proxy features; verifying generalization gains.
- Cross-architecture/model-family forecasting and transfer – sectors: model R&D
- Tools/products/workflows: Use proxies to compare and forecast capability across architectures (e.g., MoE vs. dense) and to select transfer starting points.
- Why promising: Reduces expensive head-to-head training/evaluation.
- Assumptions/dependencies: Demonstrations beyond a single architecture/scale; careful normalization across tokenizers.
- Agent evaluation without full environment access – sectors: robotics, operations research
- Tools/products/workflows: Collect expert action/state sequences and use proxy scoring over instruction-conditioned plans to predict agent performance before costly trials.
- Why promising: Mirrors “single forward pass over trajectories” idea in sequential decision making.
- Assumptions/dependencies: Mapping token-level proxies to action-sequence quality; environment-specific adjustments.
- Cluster autoscaling and cost optimization from proxy-based forecasts – sectors: cloud, platform engineering
- Tools/products/workflows: Predict training milestones and downstream accuracy to plan cluster usage and energy budgets; choose cheaper checkpoints to ship first.
- Why promising: Tighter alignment between spend and expected gains.
- Assumptions/dependencies: Mature pipeline integration; historical calibration on internal workloads.
- Educational tooling to evaluate stepwise alignment – sectors: edtech
- Tools/products/workflows: Tutors that check whether a model “tracks” expert steps in math/science explanations before using it in graded assistance.
- Why promising: Safer deployment of AI tutors by verifying process alignment, not only final answers.
- Assumptions/dependencies: High-quality pedagogical traces; validation that proxy alignment correlates with helpfulness and correctness for students.
Notes on feasibility and risks (cross-cutting):
- Dependencies common to most applications: high-quality expert trajectories that are representative of the target distribution; access to candidate model token probabilities/logprobs for forward passes; stable tokenization across comparisons.
- Known limitations from the paper: strongest evidence is on reasoning tasks and one pretraining trajectory (OLMo-3-7B); no single proxy dominates universally—selection on held-in tasks/checkpoints is needed; generalization to generative/agentic/long-context tasks is not yet established.
- Risks: Goodharting proxies if directly optimized; proxy degradation with noisy or biased experts; privacy concerns when traces contain sensitive information; API limitations that hide logprobs can impede deployment.
Glossary
- Agentic evaluation: Evaluation settings where models take sequences of actions in interactive environments. Example: "such as long-context retrieval and agentic evaluation"
- Chain-of-thought (CoT): Explicit intermediate reasoning steps or rationales used to solve a task. Example: "here we use chain-of-thought (CoTs) produced by Llama-3.3-70B"
- Compute budget: The amount of computational resources (e.g., FLOPs) allocated for training or evaluation. Example: "At matched compute budgets it dominates rBridge at almost every point where both methods are defined."
- Compute horizon: The multiplicative span of training compute over which forecasts or extrapolations are made. Example: "extrapolate downstream accuracy across an compute horizon"
- Cross-entropy loss: A measure of how well a model’s predicted distribution matches the target distribution; lower is better. Example: "Cross-entropy loss is poorly aligned with downstream capabilities,"
- Cross-family model selection: Choosing the best model among candidates from different architecture or training families for a target task. Example: "In cross-family model selection (\S\ref{sec:ranking_llms}),"
- Cross-validation (CV): A resampling method to assess generalization by splitting data/tasks into folds for training and evaluation. Example: "mean CV Spearman "
- DataDecide: A controlled testbed for evaluating pretraining data selection via small proxy models. Example: "We use the DataDecide testbed \citep{magnusson2025datadecide},"
- Decision accuracy: The fraction of pairwise choices (e.g., between data corpora) ranked correctly relative to a ground-truth ordering. Example: "Decision accuracy is the fraction of corpus pairs ranked correctly."
- Downstream accuracy: Task performance measured on target evaluations (e.g., benchmarks) after pretraining or fine-tuning. Example: "downstream accuracy across an compute horizon"
- Entropy: A measure of uncertainty in a probability distribution; higher entropy indicates more uncertainty. Example: "Entropy ()"
- Expert trajectories: Complete solution traces or reasoning steps provided by humans or strong models, used to probe a candidate model. Example: "an expert trajectory contains a long sequence of local decisions,"
- Expert-disagreement: A token-weighting scheme emphasizing positions where the model assigns low probability to the expert token. Example: "Expert-disagreement"
- FLOPs: A compute proxy counting floating-point operations, commonly used to estimate training cost. Example: "following the standard approximation "
- Gaussian kernel: A radial basis function kernel used in kernelized models (e.g., RankSVM) to capture nonlinear relations. Example: "with a Gaussian kernel"
- Gaussian-NLL: A weighting scheme based on a Gaussian negative log-likelihood around token loss values. Example: "Gaussian-NLL"
- Hinge loss: A margin-based loss used in ranking/classification (e.g., RankSVM) to enforce correct pairwise orderings. Example: "trained under a pairwise hinge loss"
- Latent capability axis: A learned one-dimensional factor summarizing model capability across tasks or benchmarks. Example: "fitting a latent capability axis over benchmark scores from public models"
- Leave-2-tasks-out cross validation: A CV protocol that holds out two tasks for testing while training/selecting on the remaining tasks. Example: "we perform leave-2-tasks-out cross validation over the six benchmarks,"
- Mixture-of-experts: An architecture that routes inputs to specialized expert subnetworks to improve efficiency or capability. Example: "mixture-of-experts architectures"
- Normalized Mean Absolute Error (NMAE): Mean absolute error normalized by the target variable’s range, used for comparable forecasting error. Example: "normalized mean absolute error (NMAE)"
- OLMES: A suite of multiple-choice benchmarks used to evaluate LLM capabilities. Example: "the OLMES suite of ten multiple-choice benchmarks"
- Pareto frontier: The set of methods not dominated in both performance and cost; improving one dimension worsens the other. Example: "pushing the Pareto frontier beyond existing methods;"
- Power law: A functional relation of the form a − b t−c used to model smooth scaling with training steps/compute. Example: "fit a power law ."
- Proxy metric: A cheap, task-conditioned signal designed to predict downstream performance without full evaluations. Example: "we propose to construct proxy metrics"
- RankSVM: A learning-to-rank method that learns to order items using pairwise preferences, linear or kernelized. Example: "RankSVM (linear)"
- Reciprocal rank: The inverse of the rank of the correct item; higher values indicate better ranking at top positions. Example: "Reciprocal rank"
- rBridge: A method that reweights token losses by expert model probabilities to predict reasoning performance. Example: "We also evaluate rBridge \citep{koh2025rbridge},"
- Scaling laws: Empirical relations describing how performance or loss scales with compute, data, and parameters. Example: "Classical scaling laws predict pretraining loss as a function of compute, parameters, and data"
- Sigmoid: An S-shaped function used to model saturating relationships, e.g., accuracy vs. log-compute. Example: "sigmoids over log-compute"
- Spearman rank correlation (ρ): A nonparametric measure of rank-order agreement between two lists. Example: "Spearman rank correlation ()"
- Top-k accuracy: The probability that the correct token appears within the model’s top-k predictions. Example: "top-k accuracy"
- Wrong-confidence: A metric capturing the model’s confidence when its top prediction is incorrect. Example: "Wrong-confidence"
Collections
Sign up for free to add this paper to one or more collections.

