Title: Sloth: scaling laws for LLM skills to predict multi-benchmark performance across families
Venue: NeurIPS 2025
Accepted: yes
Keywords: scaling law

LLM

benchmark

skill
Abstract: Scaling laws for large language models (LLMs) predict model performance based on parameters like size and training data. However, differences in training configurations and data processing across model families lead to significant variations in benchmark performance, making it difficult for a single scaling law to generalize across all LLMs. On the other hand, training family-specific scaling laws requires training models of varying sizes for every family. In this work, we propose Skills Scaling Laws (SSLaws, pronounced as Sloth), a novel scaling law that leverages publicly available benchmark data and assumes LLM performance is driven by low-dimensional latent skills, such as reasoning and instruction following. These latent skills are influenced by computational resources like model size and training tokens, but with varying efficiencies across model families. Sloth exploits correlations across benchmarks to provide more accurate and interpretable predictions while alleviating the need to train multiple LLMs per family. We present both theoretical results on parameter identification and empirical evaluations on 12 prominent benchmarks, from Open LLM Leaderboard v1/v2, demonstrating that Sloth predicts LLM performance accurately and offers insights into scaling behaviors for complex downstream tasks, increased test-time compute, and compute-optimal scaling of skills.

Sloth: scaling laws for LLM skills to predict multi-benchmark performance across families

Abstract

Scaling laws for large language models (LLMs) predict model performance based on parameters like size and training data. However, differences in training configurations and data processing across model families lead to significant variations in benchmark performance, making it difficult for a single scaling law to generalize across all LLMs. On the other hand, training family-specific scaling laws requires training models of varying sizes for every family. In this work, we propose Skills Scaling Laws (SSLaws, pronounced as Sloth ), a novel scaling law that leverages publicly available benchmark data and assumes LLM performance is driven by low-dimensional latent skills, such as reasoning and instruction following. These latent skills are influenced by computational resources like model size and training tokens, but with varying efficiencies across model families. Sloth exploits correlations across benchmarks to provide more accurate and interpretable predictions while alleviating the need to train multiple LLMs per family. We present both theoretical results on parameter identification and empirical evaluations on 12 prominent benchmarks, from Open LLM Leaderboard v1/v2, demonstrating that Sloth predicts LLM performance accurately and offers insights into scaling behaviors for complex downstream tasks, increased test-time compute, and compute-optimal scaling of skills. Our code can be found on https://github.com/felipemaiapolo/sloth .

1 Introduction

Large Language Model (LLM) scaling laws for benchmarks and downstream tasks efficiently predict the performance of an LLM based on its parameter count and training set size. However, variations in training configurations and data processing across different model families often lead to significant differences in benchmark performance, even for models with comparable compute budgets [Ruan et al., 2024]. Consequently, a single scaling law typically fails to predict performance across all LLMs accurately [Choshen et al., 2024]. In contrast, creating family-specific scaling laws requires training multiple models of increasing size, which is resource-intensive.

In this work, we propose a new class of scaling laws called Sloth to solve this dilemma. These scaling laws are fitted using publicly available data ( e.g. , from LLM leaderboards) across multiple benchmarks, leveraging information shared among benchmarks and model families to improve prediction power and interpretability through parameter efficiency, i.e. , fewer parameters without hurting performance. Specifically, we utilize the correlations in benchmark scores to simplify the scaling law in terms of parameter count without harming prediction power by assuming that LLM performance is driven by a set of low-dimensional latent skills, such as reasoning and instruction

following, which can be easily interpreted. Furthermore, we hypothesize that these latent skills are similarly influenced by computational resources, such as model size and training tokens, across different LLM families, with the key distinction being each family's efficiency in converting compute into skill levels-which can be estimated with only one model per family. In summary, our main contributions are

Introducing a new class of scaling laws, Sloth , that borrows strength across the available benchmarks and LLM families to make more accurate and interpretable performance predictions of (hypothetical) LLMs in given benchmarks of interest. Specifically, we assume that benchmark performances directly depend on low-dimensional LLM skills, which are influenced by factors such as the number of training tokens and the number of parameters.

Providing a theoretical result regarding the identification of Sloth 's parameters and empirically demonstrating that our scaling laws can (i) accurately predict the performance of large models in 12 prominent LLM benchmarks and (ii) provide interpretable insights into LLM skills and scaling behavior.

Demonstrating how predicted latent skills and our model can be used to (i) predict model performance in complex downstream tasks that involve coding and emotional intelligence, (ii) predict LLM behavior with scaled test-time compute, and (iii) derive optimal-scaling rules for skills.

1.1 Related work

Scaling laws for deep neural networks: In recent years, researchers have studied scaling laws from different angles. Rosenfeld et al. [2019] provides experimental scaling laws that predict model loss as a function of training set size, model width, and model depth. Likewise, Kaplan et al. [2020] establishes scaling laws that primarily measure loss (perplexity) and not accuracy on downstream tasks or benchmarks. Motivated by the presence of hard limits on the size of trainable data sets but a hypothetical unlimited ability to scale models, the authors of Muennighoff et al. [2023] establish scaling laws in constrained data settings. They find that perhaps unsurprisingly, increasing computing provides diminishing returns if data does not scale. Gadre et al. [2024] addresses the gap between the assumptions in scaling laws and how training is performed in practice; in particular, they construct scaling laws that both perform well in the over-training regime and predict performance on downstream tasks. In a similar but distinct direction, some works try not only to estimate scaling laws but also respond to the following strategic question: 'Given a fixed FLOPs budget, how should one trade-off model size and the number of training tokens?' For example, Hoffmann et al. [2022] provides a partial answer, introducing the celebrated family of Chinchilla scaling laws and finding that training tokens and parameter size should roughly scale together. This contrasts with the older work of Kaplan et al. [2020] that provides a series of power laws that imply that simply increasing parameter count will provide good returns. Each of these referenced works trains models with a particular pretraining setting (e.g., architecture) at various sizes and ultimately seeks to predict test loss. Our focus is distinct, we fit scaling laws on existing benchmark data of multiple model families and predict LLM benchmark performance with minimal amount of data on the new family being predicted. Even though Allen-Zhu and Li [2024], study how LLMs can retain knowledge depending on their scale, the closest related works are Owen [2024], Ruan et al. [2024], Gadre et al. [2024]; we will provide a detailed comparison with their work throughout the paper.

LLMs latent skills: Given that the performance of large language models (LLMs) in different and diverse benchmarks is correlated, it makes sense to think that those models have some lowdimensional latent skills that are reflected in downstream tasks. In this direction, Ili´ c [2023] extracts a general intelligence factor ('g-factor') for LLMs using the Open LLM Leaderboard [Beeching et al., 2023] and GLUE [Wang et al., 2018] using factor analysis. They also verify that this 'g-factor' positively correlates with model size. In a similar direction Burnell et al. [2023] uses HELM [Liang et al., 2022] data to reveal that LLM intelligence may be constituted by three distinct, yet correlated factors. They also verify a positive correlation between model size and these latent skills, yet they do not propose a formal scaling law. In their study, the authors do not account for the training set size or model family information, leading to a poor fit of the regression model; this leaves good extrapolation as an open problem we address. In Kipnis et al. [2024], a unidimensional item response theory model is applied to each one of the 6 (filtered) benchmarks of the Open LLM Leaderboard. A factor analysis on the skill parameters shows that the main factor (carrying 80% of the data variability) is highly correlated with the 'grand' (average) score of LLMs. In a related but different direction, Maia Polo et al. [2024a,b] show that inferring low-dimensional latent skills of LLMs can make model evaluation much more efficient, saving up to 140x in computing power. In this work, we explicitly model LLM

skills as a function of computing resources, which enables the creation of accurate and interpretable scaling laws for benchmark performances.

2 Scaling laws for benchmark data

2.1 Problem Statement

In this section, we describe the setup we work on and what our objectives are. Within a family of LLMs i ( e.g. , LLaMA 3), our objective is to estimate the performance of a big LLM, e.g. , with 70 billion parameters, in a benchmark j , e.g. , MMLU, given evaluation data from smaller models in the same family. Let s represent the size of the LLM, defined as the number of parameters, and let t denote the number of training tokens. We define Y ij ( s, t ) ∈ [0 , 1] as the score of an LLM from family i , with size s and trained on t tokens, on benchmark j . Our goal is to approximate:

Here, m [ · ] should be interpreted as a central tendency summary measure of a random variable, such as the mean or median 1 . Ideally, the model for µ ij will be simple and some of its parameters will be shared among model families and benchmarks; in this case, the model becomes more interpretable and more data can be used in the fitting process, making the model better estimated. From now on, we denote the set of model families as I = { 1 , · · · , I } and the set of benchmarks as J = { 1 , · · · , J } .

2.2 Previous approaches to scaling laws for benchmarks

The closest works to ours that propose models for µ ij ( s, t ) (2.1) are Owen [2024], Ruan et al. [2024], and Gadre et al. [2024]. While Gadre et al. [2024] indirectly model the quantity of interest via the LLMs perplexity in specific datasets, which might not be readily available, Owen [2024] and Ruan et al. [2024] model µ ij ( s, t ) directly through a regression model connecting compute and benchmark performance. One assumption they made is that the performance on benchmarks only depends on s and t through the total amount of training FLOPs, which can be approximated by c ( s, t ) = 6 st . That is, if σ : R → [0 , 1] denotes a fixed activation function, e.g. , the standard logistic (sigmoid) function, and γ j ∈ [0 , 1] , then it is assumed that

where η ij : R 2 → R denotes a linear predictor such that η ij ( s, t ) = α ij + β ij log c ( s, t ) , which can be easily interpreted. Here, γ j adjusts the lower asymptote of µ ij and accounts for the probability of LLMs scoring correctly by chance. Owen [2024], in their best performing models, considers the case in which γ j = 0 (or adds a similar offset parameter to the model) and the parameters α ij and β ij are independent of the model family i . On the other hand, Ruan et al. [2024] consider both α ij and β ij to be family-dependent and, in their most general model, γ j can assume values in [0 , 1] .

The biggest issue with previous approaches when modeling µ ij is that they are either too restrictive or too flexible. From the restrictive side, they assume that (i) µ ij depends on s and t only through FLOPs, (ii) there are no family-dependent parameters, or (iii) the activation function σ is fixed and well-specified. From the flexibility side, Ruan et al. [2024] assume both α ij and β ij to be family dependent making estimation hard (or impossible) depending on the number of models we see for each family. From Ruan et al. [2024]: '(...) fitting such a scaling law can be tricky, as each model family f and downstream benchmark has its own scaling coefficients β f and α f . This means that scaling experiments, especially for post-training analysis, are often fitted on very few (3-5) models sharing the same model family (...).' Thus, in their experiments, they consider a different problem setting, where a large LLM has been trained and evaluated on some benchmarks and use their method to predict its performance on other benchmarks.

At the end of the day, Owen [2024] and Ruan et al. [2024] end up working in different setups: Owen [2024] does not use family information at prediction time, making their scaling law less accurate but more generalizable, and Ruan et al. [2024] assume families are important at prediction time but consider that the target model has already been trained, making their scaling law less applicable in practice and more interesting from an interpretability point of view. In this work we wish to instead predict the performance of a larger LLM without having to train it but taking family information into account, thus allowing practitioners to make decisions regarding investing resources into training

large LLMs. Moreover, our formulation also allows interpretable insights from the data. Despite different setups, we make comparisons with Owen [2024] and Ruan et al. [2024] throughout this work by considering their applications/adaptations as baselines.

3 Scaling laws for LLMs skills with Sloth

3.1 Model architecture

We present a novel scaling law called Sloth , which introduces several modifications to (2.2). The key innovation of Sloth lies in its explicit modeling of the correlation structure between benchmarks, resulting in improved predictive accuracy and interpretability. Moreover, Sloth proposes that (i) LLM capabilities should scale with computing resources similarly across families up to an efficiency factor, (ii) benchmark performance can depend on s and t not only through the total number of FLOPs, and (iii) that the function σ can also be learned in cases in which predictive performance is important. We detail these points.

Inspired by the latent skills ( e.g. , reasoning, language modeling, instruction following) inferred from benchmark data in Burnell et al. [2023], Ili´ c [2023], Ruan et al. [2024], Gor et al., Kipnis et al. [2024], Maia Polo et al. [2024a,b], we propose creating a scaling law for LLMs skills by leveraging the correlation structure of the benchmarks; for example, we model how the construct 'reasoning' scales with compute instead of modeling benchmarks scores directly. The two major advantages of this approach are better performance prediction since we have fewer parameters to fit (reducing overfitting) and extra interpretability/insights. Concretely, we model η ij ( s, t ) 's simultaneously for benchmarks j ∈ J as each being a linear combination of the same low-dimensional latent skills θ i ( s, t ) ∈ R d plus a bias term b ∈ R J , where d ≪ J = |J | . Denote η i ( s, t ) ∈ R J as the vector of { η ij ( s, t ) } j ∈J . Mathematically, we have

One can see that Λ ∈ R J × d encodes the correlation structure between the benchmarks; in particular, it tells us which benchmark measures overlapping (or distinct) skills. Interestingly, our model has a strong connection with factor analysis (FA) models, which we elaborate on in detail in Appendix C. In FA, the matrix Λ is known as factor loadings while θ i ( s, t ) are known as factors.

Next, we propose a model for θ i ( s, t ) . Inspired by models used in Economics, we use the family of translog production functions from stochastic frontier analysis [Kumbhakar and Lovell, 2003]:

Note that (i) the intercept parameter α ik is indeed family-dependent while each skill slope is shared across families and (ii) θ i can depend on s and t not only through c ( s, t ) . In economic terms, the intercept term α ik can be interpreted as an efficiency measure of the family i in converting compute to performance for skill k and, in practice, will absorb all hidden factors specific to family i such as data quality, post-training factors, etc. . We note that the interaction term in ( log( s ) log( t ) ) accounts for the fact that the impact of log( s ) and log( t ) on skills might depend on each other; in Appendix D, we show some evidence that this is indeed the case. Additionally to the changes in η ij , we propose making the activation function σ trainable and specific to each benchmark j if needed. To that end, we adopt a semi-parametric single-index model using neural networks [Bietti et al., 2022]. To make the results more behaved if (out-of-support) generalization is needed, we assume σ j : R → [0 , 1] is given by a monotonic (increasing) neural network, which can be achieved by constraining its weights to be non-negative [Sill, 1997] and its last activation function to be sigmoid. We note, however, that one can always forgo training of the link function and instead assume a sigmoid structure as this simplifies model fitting and may make the model more interpretable. We give more details about model fitting in Section 3.2. Since Sloth is a simple neural network, both model fitting and prediction are done within seconds by a commercial laptop.

3.2 Model fitting

Assume that for each model family i we observe a set of tuples ( s, t ) 's denominated by E i . Then, we fit the model by solving the following minimization problem

where ℓ δ is given by the Huber loss with hyperparameter δ = . 01 and µ ij ( s, t ) denotes the most general version of our model. We minimize the loss function via gradient descent using the Adam optimizer [Kingma and Ba, 2017] with a decaying learning rate. We parameterize γ j using the sigmoid transformation to guarantee the constraints are satisfied. Similarly, we truncate the weights of the two-hidden-layer neural network σ j to ensure the trainable function is increasing. If one desires, σ j 's can be set to fixed functions, e.g. , sigmoid, and γ j 's can be fixed beforehand. Unfortunately, the minimization problem is not convex as expected when fitting factor-analysis-like models; multiple initializations of the optimizer can be applied to guarantee a better fit.

3.3 Interpretability and practical considerations post model fitting

Ideally, to make reasonable interpretations of models like Sloth , we need its parameters to be identifiable, i.e. , the map connecting η ij ( s, t ) 's and model parameters should be bijective. Unfortunately, as in all exploratory factor models, this is not the case. However, we theoretically show in Appendix A that the model parameters are identifiable up to some parameter transformations. This observation allows us to find a configuration that makes the model more interpretable by mirroring a standard approach used in factor analysis, e.g. , in Chen et al. [2019]'s applications. The main idea is that we fit Sloth without any constraints and then find a configuration of skills (using factor rotation) that makes results interpretable. We detail the applied process in Appendix A.1.

4 Sloth in practice

In this section, we present experimental results that provide evidence of the usefulness of Sloth . We perform experiments on a set of twelve benchmarks and state-of-the-art LLM families, including LLaMa 3 [Dubey et al., 2024], Qwen 2 [Yang et al., 2024], and Yi 1.5 [Young et al., 2024]. We explore the following applications: (i) benchmark performance prediction for larger models from a specific LLM family, (ii) interpretability of the scaling of skills (can help practitioners allocate resources based on the skills of interest), and (iii) downstream tasks performance prediction.

4.1 Data

We expand the dataset made available by Ruan et al. [2024], including more models from the HuggingFace Open LLM leaderboard v1 [Beeching et al., 2023] and v2 [Fourrier et al., 2024]. In our extended dataset, we have a total of 30 families 2 , which 28 are on v1 of the Open LLM Leaderboard and 17 families measured on v2 of the Open LLM Leaderboard. Furthermore, there are 15 families at the intersection of the two versions. Furthermore, we collect data and present results on the performance of a variety of instruction-tuned versions of the base models we consider. As far as we are aware, our dataset is the most comprehensive among prior works on benchmark data scaling laws. Please check Appendix G for details on the included models.

4.2 Comparing scaling laws in terms of prediction errors

In this section, we compare the predictive power of different scaling laws in predicting LLM performance in all the considered benchmarks; we focus on the two versions of the Open LLM Leaderboard, which include 12 benchmarks: GSM8k [Cobbe et al., 2021], MATH Lvl 5 [Hendrycks et al., 2021], MMLU [Hendrycks et al., 2020], MMLU-PRO [Wang et al., 2024], BBH [Suzgun et al., 2022], GPQA [Rein et al., 2023], MUSR [Sprague et al., 2023], TruthfulQA [Lin et al., 2021], HellaSwag [Zellers et al., 2019], Winogrande [Sakaguchi et al., 2019], ARC [Clark et al., 2018], and IFEval [Zhou et al., 2023]. We apply a leave-one-out cross-validation algorithm to obtain test errors for each family of models. We consider base models and instruct models to belong to distinct

MMLU

ARC

Winogrande

TruthfulQA

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.4

6.2

7.1

5.2

6.4

12.4

7.8

6.5

3.0

3.0

2.2

9.0

5.7

4.9

7.1

3.2

3.8

2.6

4.5

5.2

4.4

8.7

5.6

7.5

4.7

4.5

13.1

7.3

8.7

3.1

4.2

2.1

4.3

13.8

6.0

10.0

3.2

4.8

2.0

6.0

12.1

6.3

9.7

3.2

4.9

2.0

6.2

12.2

6.4

8.3

6.8

9.8

5.3

6.5

13.5

8.4

7.4

4.1

6.8

3.5

4.2

9.1

5.8

5.8

3.9

6.1

3.4

5.4

7.4

5.3

5.7

4.6

6.3

3.2

5.0

5.9

5.1

8.2

3.1

4.4

2.5

4.4

11.0

5.6

4.4

2.7

4.2

2.9

3.8

7.7

4.3

4.8

2.8

4.0

2.8

4.9

6.3

4.2

5.3

2.7

3.6

2.6

4.2

5.9

4.1

Open LLM Leaderboard v1

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.4

4.5

4.2

2.6

2.8

5.6

4.9

5.1

3.6

2.6

2.5

4.4

4.5

3.8

4.9

3.8

3.3

3.0

2.8

6.8

4.1

9.3

7.3

4.4

2.7

3.2

9.4

6.0

6.1

7.4

4.3

2.7

2.8

9.3

5.4

6.1

7.1

5.3

2.7

2.6

9.1

5.5

6.1

7.1

5.5

2.7

3.7

8.9

5.7

9.2

6.0

3.8

2.3

2.3

7.5

5.2

4.8

4.1

3.2

2.2

1.9

5.6

3.6

4.8

4.3

2.9

2.2

3.0

5.7

3.8

4.8

5.0

3.8

2.2

3.3

5.9

4.2

9.9

4.2

2.6

1.9

2.0

4.2

4.1

4.9

2.6

2.3

2.5

2.2

2.6

2.9

4.8

2.5

4.1

2.4

4.0

3.1

3.5

4.8

2.4

4.3

2.0

2.9

3.5

3.3

Open LLM Leaderboard v2

families (they will not share the same intercept in our model, for example), but we do not include the instruct (resp. base) family in the training set when the corresponding base (resp. instruct) family is in the test set. Moreover, we do not test older versions of recent families if they are available in the training set, e.g. , we do not include LLaMa 2 in the set of test families if LLaMa 3 is present in the training set. In this section, we present results for the two leaderboards separately; in Figures 12 and 17 of the Appendix, we also present results for the intersection of the two leaderboards.

In the first set of experiments, we consider the case in which only the smallest model of the test family is observed at training time. Because of that reason, we cannot fit the general scaling law in (2.2) in which both the intercept and slope are family dependent. In this scenario, we consider our main baselines to be (i) the model in (2.2) with shared intercept and slope [Owen, 2024] ('FLOPs (shared intercept)'), (ii) the same model but only with shared slope ('FLOPs'), (iii) a version of the PCA idea 3 proposed by Ruan et al. [2024] in which we predict the principal components using the FLOPs model with shared slope that are then mapped to the benchmark scores ('PCA + FLOPs'), (iv) and our model with trainable activation function but assuming Λ is identity ('Size and Tokens'; implies d = J ). Moreover, we include two versions of Sloth . In the 'basic' one, we fix σ to be sigmoid, and γ j 's are given by the 100% over the number of alternatives in the case of multiple-choice benchmarks 4 and 0 otherwise, except for TruthfulQA, which we compute the first percentile of the scores coming from the full Open LLM Leaderboard and fix the lower asymptote to that value. In previous sections, we mentioned that Sloth is parameter efficient; we include a parameter count analysis in Appendix F where we compare our model with other well-performing baselines.

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

Reasoning

Knowledge

Instruction

Following

3.43

3.42

2.30

1.71

1.78

1.65

0.86

0.60

0.65

0.51

0.66

0.05

-0.51

-0.60

0.06

0.11

0.07

0.15

0.06

-0.00

0.44

0.55

0.56

0.04

0.03

-0.02

-0.22

-0.01

0.00

0.03

-0.02

0.33

0.07

0.05

-0.01

0.63

2.2

0.5

0.0

0.5

1.0

1.5

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Reasoning

0.60

0.45

0.30

0.15

0.00

0.15

0.30

0.45

0.60

0.75

0.90

1.05

1.20

0.5

0.0

0.5

1.0

1.5

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Knowledge

1.5

1.0

0.5

0.0

0.5

1.0

1.5

2.0

2.5

3.0

3.5

0.5

0.0

0.5

1.0

1.5

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Instruction

Following

0.4

0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

1.6

1.8

2.0

Figure 1 gives the results for the first set of experiments. It depicts the average mean absolute error of all methods when predicting LLM benchmark performance, which is measured in percentage points. It shows the competitiveness of Sloth in terms of prediction quality. One important thing to notice is that Sloth errors are similar or lower than the 'Size and Tokens' variant, suggesting that the assumed low-dimensional structure between benchmarks results is a good inductive bias. We highlight that the analysis includes recent families like LLaMa 3, Qwen 2, and Yi 1.5. For more details on the tested models and extra related results, including model-specific results, please check Appendix H.2. The extra results are qualitatively similar

TruthfulQA

BBH

MATH Lvl 5

GPQA

FLOPs (shared

intercept)

Sloth

(d=3)

Sloth (d=4)

(shared intercept)

5.4

6.6

5.3

4.8

2.7

4.4

5.0

2.5

1.6

2.2

4.8

5.4

3.8

3.0

2.2

to the ones in Figure 1, in which Sloth often beats the baselines. In a second set of experiments, we consider the case in which the two smallest models of the test family are observed at training time. In this way, we can fit (2.2) making both parameters family dependent. The results are qualitatively similar to the one presented on Figure 1 and are presented in Appendix H.3. Moreover, we include Figure 10 in the appendix, which is a version of Figure 1 in which Mean Absolute Percentage Error (MAPE) is used instead of MAE; results are qualitatively similar.

In an extra set of experiments, we show that family-specific intercept models are not always needed; we can still get good prediction results for some benchmarks even if we consider a shared intercept between families. The advantage of this approach is that we can claim for a general scaling law that holds for all families. Figure 3 shows us a subset 5 of Figure 12 in the appendix and it is built under the same conditions as Figure 1. It is possible to see that, for a subset of benchmarks Sloth with shared intercept is a strong alternative to the FLOPs model used by Owen [2024]. In some cases, it gets similar prediction errors relative to more complete versions of Sloth .

Instruction

0.7

0.2

0.3

0.7

1.2

Base model skill (z-score)

0.7

0.2

0.3

0.7

1.2

Instruct model skill (z-score)

Reasoning

2.1

1.2

0.3

0.6

1.5

Base model skill (z-score)

2.1

1.2

0.3

0.6

1.5

Knowledge

2.1

0.7

0.8

2.2

3.6

Base model skill (z-score)

2.1

0.7

0.8

2.2

3.6

Following

Families

falcon

llama-2

meta-llama-3

qwen1.5

recurrentgemma

yi-1.5

4.3 Interpreting the latent skills

In this section, we use the intersection between the two leaderboards, aiming to get more insights from the combined data. Since we have an identifiability result for the 'basic' version of Sloth , in which we fix the lower asymptotes γ j 's and the link function to be sigmoid (see Section A), we opt for interpreting that version of the model. We set d = 3 as that model version achieved the best prediction results in Figure 12. Figure 2 illustrates the model loadings, Λ , from which we assign names to the three dimensions based on our subjective interpretation. We include the loadings for d = 2 and d = 4 in Appendix I. To complement our exploration, we include Figure 4, which gives us the level curves of different skills (disregarding the family-specific intercept term), and Figure 5 in the appendix that compares the skills of base and instruction-tuned models; in this figure, we include LLM families with more number of models. In both figures, the numbers are given in terms of standard deviations as the skills are standardized to have a zero mean and unitary standard deviation.

Reasoning skill: The first dimension, with strong loadings from benchmarks such as GSM8K, MATH, GPQA, MMLU(-PRO), BBH, and MUSR, is labeled 'Reasoning.' The benchmarks GSM8k and MATH Lvl 5 consist entirely of mathematical word problems while MMLU/MMLU-PRO and GPQA also contain mathematical and advanced science questions. On the other hand, BBH includes logic deduction and linguistic reasoning puzzles. The strong dependence of BBH on the 'Reasoning' skill suggests that in language models, there is an association between logical reasoning, general linguistic ability, and mathematical ability. Finally, MuSR is a benchmark that evaluates 'multistep soft reasoning tasks specified in a natural language narrative' [Sprague et al., 2023]. Figure 4 shows that Reasoning is primarily a function of model size, with a small dependence on the number of training tokens used. Moreover, the first plot of Figure 5 in the appendix compares base models versus their instruction-tuned versions in terms of Reasoning, and we found that there is no clear rule: instruction tuning can either increase or decrease the ability of an LLM to reason. These findings are robust for different values of d as we can see in the figures of Appendix I.

Knowledge skill: The second dimension is positively loaded on ARC, HellaSwag, and Winogrande. These three benchmarks measure the ability of LLMs to remember common sense and basic knowledge; we denominate this skill as 'Knowledge'. More specifically, ARC consists of grade school-level science questions, HellaSwag is meant for sentence completion for common scenarios, and Winogrande common sense pronoun resolution problems. Contrasting with Reasoning, Figure 4 shows that Knowledge is highly influenced by both model size and number of training tokens. Moreover, we can see that the range of standard deviations in the middle plot is much greater than in the other two plots, giving us evidence that this skill might be more sensitive to increases in compute resources and less dependent on the LLM families themselves. On the other hand, Figure 5 in the appendix does not show any strong evidence of the effect of instruction tuning on this skill. These findings are similar to the ones reported in Appendix I for different values of d .

Instruction following skill: IFEval, which is positively and heavily loaded in this skill, measures how well language models produce answers that follow a verifiable set of instructions; for example, including a keyword x number of times in responses. Therefore, we call it 'Instruction Following'. An interesting fact is that instruction tuning has a strong positive effect on this skill for all depicted families we can see in Figure 5 in the appendix. The effect can also be observed in Figure 28 of the appendix. When d = 2 , instruction following gets mixed with other skills and we are not able to see

this effect. Regarding Figure 4, we see that Instruction Following depends on both model size and tokens. Unfortunately, this interpretation does not hold when d = 4 as seen in Appendix I.

4.4 Predicting LLM performance on downstream tasks

Another useful application of Sloth , which is inspired by Ruan et al. [2024], is to predict the performance in a downstream task for a large model from a relatively small number of prior performance observations from that task. We use Sloth to estimate the latent skills of hypothetical LLMs and then use them to predict the performance of those LLMs in downstream tasks. With this approach, we expand on the experiments of Ruan et al. [2024], which do not consider performance prediction of hypothetical LLMs.

The basic prediction pipeline is as follows. First, use standard LLM leaderboards to fit a scaling law for skills using Sloth . Second, use existing LLM performance on the downstream task to model how performance can be predicted from latent skills. Third, use Sloth to predict the skills of a (hypothetical) LLM of interest, e.g. , a larger version of an existing LLM. Finally, use the model fitted in the second step to predict the performance of the hypothetical model in the downstream task.

We evaluate this pipeline on two downstream tasks, predicting the performance of meta-llama-3-70B and meta-llama-3-70B-instruct on code completion and meta-llama-3-70B-instruct on emotional intelligence tasks. We fit the same model shown in Section 4.3, but do not include meta-llama-3-70B or meta-llama-3-70B-instruct in the training set (see Figure 32 for the loadings of the latent skills, which is similar to Figure 2). Next, using either HumanEval [Chen et al., 2021] or EQ bench data [Paech, 2024], we fit a regression model with logistic link using latent skills as features and performance on the downstream task as target. Together, this provides us with sufficient information to predict the performance of the held-out models on both tasks with decent accuracy. Figure 6 depicts this logistic curve and the actual values for HumanEval;

4

2

0

2

4

T

HE

i

(

s

,

t

) +

c

0.0

0.2

0.4

0.6

0.8

HE Accuracy

Prediction

Training Data

meta-llama-3-70b

meta-llama-3-70b-instruct

0

1

2

1.35

-0.02

0.22

HE

EQ bench results can be found in Appendix J. Moreover, we can see that 'Reasoning' is by far the most important skill in predicting coding ability while a mixture of 'Reasoning' and 'Knowledge' is needed for emotional intelligence (see Figure 32 for a more accurate interpretation of the loadings).

In Appendix J, a similar test is provided for agentic capability measured by AgentBench [Liu et al., 2023], although to avoid overfitting, in this case, we must fit Sloth with no family-specific intercept.

4.5 Predicting performance behavior with scaled inference compute

In this section, we demonstrate how our method, Sloth , combined with concepts like Item Response Theory (IRT) [Reckase, 2009], can predict how the performance of an LLM scales with increased inference through repeated sampling [Brown et al., 2024]. For this experiment, we utilize the MATH dataset [Hendrycks et al., 2021], made available by Brown et al. [2024], which evaluates 10 LLMs also included in our dataset. These models are part of the LLaMa 3 Instruct, Gemma, and Pythia families. The process is:

Train Sloth on our full dataset of 12 benchmarks, excluding the largest models in the LLaMa 3 Instruct, Gemma, and Pythia families.

Fit a logistic regression model for each MATH question in Brown et al. [2024]'s data, using the skills θ i ( s, t ) of the 7 training LLMs as covariates to predict the probability of correctly solving those problems.

Estimate the skills for the three test models using our scaling law, then predict their probabilities of answering each MATH question correctly via the logistic regressions, and then predict the pass@ k metrics for the 3 test models using those probabilities. The predicted pass@ k metric for a certain LLM is given by the average of 1 -(1 -ˆ p j ) k 's (across j 's) if ˆ p j is the predicted probability of the LLM of interest getting question j correct.

Figure 7 illustrates that Sloth can accurately predict test-time scaling behavior for these models. Note that unlike scaling law in Brown et al. [2024], Sloth can predict inference compute gains for hypothetical LLMs before committing resources to training them. This highlights a practical application where practitioners can estimate the potential performance of a hypothetical model at test time, given a computational budget.

4.6 Compute-optimal scaling of skills

One relevant question is: given a certain budget in FLOPs, how do we invest it to maximize one skill of interest? This type of analysis is novel for skills and it has only been carried out for validation loss ( e.g. , by Kaplan et al. [2020], Hoffmann et al. [2022]). A summary of the mathematical formulation of this question is given in the following and exposed in detail in Appendix B. For each model family i and skill k , we have

Define u = log( s ) , v = log( t ) , and l = log( c ) -log(6) . For simplicity, here we consider a simple, but widely used [Kaplan et al., 2020, Hoffmann et al., 2022], compute budget constraint 6 st = c , which is equivalent to u + v = l . We add extra constraints on u and v based on the training data support to avoid unreasonable out-of-support predictions. We optimize

10 0

10 1

10 2

10 3

10 4

Trials (k)

0.0

0.2

0.4

0.6

0.8

1.0

Coverage (pass@k)

Ground truth

Sloth+IRT

prediction

Gemma-7B

LLaMa-3-70B-Inst.

Pythia-12B

Substituting v = l -u reduces this to a quadratic function g ik ( u ) , whose maximizer, within the observed range U = [max( l -v, u ) , min( l -v, u )] , determines the optimal allocation. Our analysis indicates that the optimal values for s and t do not depend on the model family. Table 1 reports our results for instruction following; a table with results for the other two skills is shown in Appendix B.

5 Conclusion

In conclusion, we have introduced the Sloth scaling laws as a novel approach to predicting the performance of large language models across benchmarks and model families. By leveraging the correlations between benchmark scores and assuming that LLM performance is governed by a set of interpretable, low-dimensional latent skills, our approach offers a more efficient and flexible framework for understanding and predicting LLM behavior. The ability to estimate model performance across a variety of bench-

marks and tasks, even with minimal data from individual model families, highlights the practical utility of Sloth scaling laws. Our empirical results demonstrate that Sloth can accurately predict the performance of LLMs across multiple benchmarks while providing insights into the relationship between computational resources and model capabilities.

Limitations. From the predictive side of Sloth , we believe that the main limitation is that the model is still dependent, most of the time, on seeing data from at least one LLM from the LLM family of interest. Moreover, we train the link function in the best version of Sloth using flexible neural networks, which can interpolate data very well, but have no guarantee of extrapolation when the (hypothetical) LLM of interest is very different from others in the training set. From the interpretability side, we only understand the identification problems, such as transformations in the latent space, that can arise in a simple instance of Sloth : fixed activation function σ and γ j 's. This fact limits our understanding and interpretability of the most advanced versions of the model.

References

Zeyuan Allen-Zhu and Yuanzhi Li. Physics of language models: Part 3.3, knowledge capacity scaling laws. arXiv preprint arXiv:2404.05405 , 2024.

Edward Beeching, Clémentine Fourrier, Nathan Habib, Sheon Han, Nathan Lambert, Nazneen Rajani, Omar Sanseviero, Lewis Tunstall, and Thomas Wolf. Open llm leaderboard., 2023. URL https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard,2023.

Alberto Bietti, Joan Bruna, Clayton Sanford, and Min Jae Song. Learning single-index models with shallow neural networks. Advances in Neural Information Processing Systems , 35:9768-9783, 2022.

Jeremy Biggs. Factor_analyzer documentation. Release 0.3 , 1, 2019.

Christopher M Bishop and Nasser M Nasrabadi. Pattern recognition and machine learning , volume 4. Springer, 2006.

Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787 , 2024.

Ryan Burnell, Han Hao, Andrew RA Conway, and Jose Hernandez Orallo. Revealing the structure of language model capabilities. arXiv preprint arXiv:2306.10062 , 2023.

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Josh Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code. 2021.

Yunxiao Chen, Xiaoou Li, and Siliang Zhang. Joint maximum likelihood estimation for highdimensional exploratory item factor analysis. Psychometrika , 84:124-146, 2019.

Leshem Choshen, Yang Zhang, and Jacob Andreas. A hitchhiker's guide to scaling law estimation. arXiv preprint arXiv:2410.11840 , 2024.

Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge, 2018. URL https://arxiv.org/abs/1803.05457 .

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021. URL https://arxiv.org/ abs/2110.14168 .

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783 , 2024.

Clémentine Fourrier, Nathan Habib, Alina Lozovskaya, Konrad Szafer, and Thomas Wolf. Open llm leaderboard v2. https://huggingface.co/spaces/open-llm-leaderboard/open_llm_ leaderboard , 2024.

Samir Yitzhak Gadre, Georgios Smyrnis, Vaishaal Shankar, Suchin Gururangan, Mitchell Wortsman, Rulin Shao, Jean Mercat, Alex Fang, Jeffrey Li, Sedrick Keh, Rui Xin, Marianna Nezhurina, Igor Vasiljevic, Jenia Jitsev, Luca Soldaini, Alexandros G. Dimakis, Gabriel Ilharco, Pang Wei Koh, Shuran Song, Thomas Kollar, Yair Carmon, Achal Dave, Reinhard Heckel, Niklas Muennighoff,

and Ludwig Schmidt. Language models scale reliably with over-training and on downstream tasks, 2024. URL https://arxiv.org/abs/2403.08540 .

Maharshi Gor, Tianyi Zhou, III Hal Daumé, and Jordan Boyd-Graber. Do great minds think alike? investigating human-ai complementarity for question answering.

Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring Massive Multitask Language Understanding. In International Conference on Learning Representations , October 2020.

Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset, 2021. URL https://arxiv.org/abs/2103.03874 .

Jordan Hoffmann, 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.

David Ili´ c. Unveiling the general intelligence factor in language models: A psychometric approach. arXiv preprint arXiv:2310.11616 , 2023.

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, 2020. URL https://arxiv.org/abs/2001.08361 .

Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv:1412.6980 [cs] , January 2017.

Alex Kipnis, Konstantinos Voudouris, Luca M Schulze Buschoff, and Eric Schulz. metabench - a sparse benchmark to measure general ability in large language models. arXiv preprint arXiv:2407.12844 , 2024.

Subal C Kumbhakar and CA Knox Lovell. Stochastic frontier analysis . Cambridge university press, 2003.

Percy Liang, Rishi Bommasani, Tony Lee, Dimitris Tsipras, Dilara Soylu, Michihiro Yasunaga, Yian Zhang, Deepak Narayanan, Yuhuai Wu, Ananya Kumar, et al. Holistic evaluation of language models. arXiv preprint arXiv:2211.09110 , 2022.

Stephanie Lin, Jacob Hilton, and Owain Evans. Truthfulqa: Measuring how models mimic human falsehoods. arXiv preprint arXiv:2109.07958 , 2021.

Xiao Liu, Hao Yu, Hanchen Zhang, Yifan Xu, Xuanyu Lei, Hanyu Lai, Yu Gu, Hangliang Ding, Kaiwen Men, Kejuan Yang, Shudan Zhang, Xiang Deng, Aohan Zeng, Zhengxiao Du, Chenhui Zhang, Sheng Shen, Tianjun Zhang, Yu Su, Huan Sun, Minlie Huang, Yuxiao Dong, and Jie Tang. AgentBench: Evaluating LLMs as Agents, October 2023.

Felipe Maia Polo, Lucas Weber, Leshem Choshen, Yuekai Sun, Gongjun Xu, and Mikhail Yurochkin. tinybenchmarks: evaluating llms with fewer examples. arXiv preprint arXiv:2402.14992 , 2024a.

Felipe Maia Polo, Ronald Xu, Lucas Weber, Mírian Silva, Onkar Bhardwaj, Leshem Choshen, Allysson Flavio Melo de Oliveira, Yuekai Sun, and Mikhail Yurochkin. Efficient multi-prompt evaluation of llms. arXiv preprint arXiv:2405.17202 , 2024b.

Niklas Muennighoff, Alexander M. Rush, Boaz Barak, Teven Le Scao, Aleksandra Piktus, Nouamane Tazi, Sampo Pyysalo, Thomas Wolf, and Colin Raffel. Scaling data-constrained language models, 2023. URL https://arxiv.org/abs/2305.16264 .

David Owen. How predictable is language model benchmark performance? arXiv preprint arXiv:2401.04757 , 2024.

Samuel J. Paech. Eq-bench: An emotional intelligence benchmark for large language models, 2024. URL https://arxiv.org/abs/2312.06281 .

Mark D Reckase. 18 multidimensional item response theory. Handbook of statistics , 26:607-642, 2006.

MDReckase. Multidimensional Item Response Theory . Springer Science & Business Media, 2009.

David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R. Bowman. Gpqa: A graduate-level google-proof q&a benchmark, 2023. URL https://arxiv.org/abs/2311.12022 .

Jonathan S. Rosenfeld, Amir Rosenfeld, Yonatan Belinkov, and Nir Shavit. A constructive prediction of the generalization error across scales, 2019. URL https://arxiv.org/abs/1909.12673 .

Yangjun Ruan, Chris J. Maddison, and Tatsunori Hashimoto. Observational Scaling Laws and the Predictability of Language Model Performance, July 2024.

Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale, 2019. URL https://arxiv.org/abs/1907. 10641 .

Joseph Sill. Monotonic networks. Advances in neural information processing systems , 10, 1997.

Zayne Sprague, Xi Ye, Kaj Bostrom, Swarat Chaudhuri, and Greg Durrett. Musr: Testing the limits of chain-of-thought with multistep soft reasoning. arXiv preprint arXiv:2310.16049 , 2023.

Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc V. Le, Ed H. Chi, Denny Zhou, and Jason Wei. Challenging bigbench tasks and whether chain-of-thought can solve them, 2022. URL https://arxiv.org/ abs/2210.09261 .

Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461 , 2018.

Yubo Wang, Xueguang Ma, Ge Zhang, Yuansheng Ni, Abhranil Chandra, Shiguang Guo, Weiming Ren, Aaran Arulraj, Xuan He, Ziyan Jiang, Tianle Li, Max Ku, Kai Wang, Alex Zhuang, Rongqi Fan, Xiang Yue, and Wenhu Chen. Mmlu-pro: A more robust and challenging multi-task language understanding benchmark, 2024. URL https://arxiv.org/abs/2406.01574 .

An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, et al. Qwen2 technical report. arXiv preprint arXiv:2407.10671 , 2024.

A Yates. Multivariate exploratory data analysis: A perspective on exploratory factor analysis . State University of New York Press, 1987.

Alex Young, Bei Chen, Chao Li, Chengen Huang, Ge Zhang, Guanwei Zhang, Heng Li, Jiangcheng Zhu, Jianqun Chen, Jing Chang, et al. Yi: Open foundation models by 01. ai. arXiv preprint arXiv:2403.04652 , 2024.

Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can a machine really finish your sentence?, 2019. URL https://arxiv.org/abs/1905.07830 .

Jeffrey Zhou, Tianjian Lu, Swaroop Mishra, Siddhartha Brahma, Sujoy Basu, Yi Luan, Denny Zhou, and Le Hou. Instruction-following evaluation for large language models, 2023. URL https://arxiv.org/abs/2311.07911 .

A Identifiability of model parameters and interpretability

To interpret Sloth parameters, we need to guarantee they are identifiable. Given that our scaling law models the function µ ij ( s, t ) = E [ Y ij ( s, t )] , that condition is equivalent to the following statement: if two sets of parameters are responsible for characterizing µ ij ( s, t ) , then those set of parameters should be the same up to predictable variations such as translations or rotations. To prove identifiability, we work with a fixed and invertible σ , as usually done in the literature, and assume γ j 's are fixed. The last condition is reasonable since these constants are usually known beforehand, e.g. , it is well accepted that the lower asymptote γ j for MMLU [Hendrycks et al., 2020] performance is 25% which is given by 100% divided by the number of multiple-choice alternatives. Denote our fixed design matrix as X ∈ R n × p , where each row is given by an LLM and p equals 3 plus the number of families, and define

such that the rows of XB ∈ R n × d give the skills vectors θ ( i ) ≜ ( XB ) ( i ) 's of all models in our dataset. Here n denotes the total number of models in the dataset and m is the total number of model families. To prove identifiability, we adopt standard assumptions from the factor analysis literature [Chen et al., 2019] or regression literature, which assumes that the skills vectors θ ( i ) ∈ R 1 × d 's are standardized, i.e. , their average is null while their covariance matrix is fixed, rank (Λ) = d , and rank ( X ) = p .

Assumption A.1 (Identifiability constraints) . Assume that

and that rank (Λ) = d and rank ( X ) = p , where θ ( i ) denotes the i -th row of XB and Ψ is a positive definite matrix.

One possible choice for the covariance matrix is Ψ = I d [Chen et al., 2019], which assumes uncorrelated skills. One implicit implication of Assumption A.1 is that n ≥ p ≥ d must be satisfied, otherwise the covariance matrix cannot be full rank. This condition is satisfied in our experiments. Under Assumption A.1, we show the identifiability of the model parameters up to a transformation of Λ tied to a transformation of B , which leaves the outputs of the model unchanged. This means that we can potentially approximate the true values for Λ and B up to a transformation, which is usually the norm within the class of exploratory factor analysis models.

Theorem A.2. Given that the true set of model parameters is (Λ , b, B ) , if there is another set of parameters ( ˜ Λ , ˜ b, ˜ B ) that satisfy

then, under the Assumption A.1, we have ˜ b = b , ˜ Λ = Λ M , and ˜ B = B ( M ⊤ ) -1 for an invertible matrix M ∈ R d × d . In particular, M is orthogonal if Ψ = I d , i.e., M ⊤ M = MM ⊤ = I d .

Proof. We start proving that b = ˜ b . Because σ is invertible, we get

and consequently by the standardization of the latent skills

Now, we prove that ˜ Λ = Λ M . Given that b = ˜ b , we have

and consequently by the standardization of the latent skills

By Cholesky's decomposition, we can write Ψ = LL ⊤ , for a lower triangular matrix L . If we define Λ ′ ≜ Λ L and ˜ Λ ′ ≜ ˜ Λ L , then

Because rank (Λ) = d , we have that rank (Λ ′ ) = d and we claim that ˜ Λ ′ = Λ ′ U for an orthogonal matrix U ∈ R d × d . To see that, first, realize that

rank (Λ ′ ) = rank (Λ ′ Λ ′⊤ ) = rank ( ˜ Λ ′ ˜ Λ ′⊤ ) = rank ( ˜ Λ ′ ) . We see this by realizing that the null spaces of Λ ′⊤ and Λ ′ Λ ′⊤ are the same: for an arbitrary vector z , Λ ′⊤ z = 0 ⇒ Λ ′ Λ ′⊤ z = 0 and Λ ′ Λ ′⊤ z = 0 ⇒ Λ ′⊤ Λ ′ Λ ′⊤ z = 0 ⇒ Λ ′⊤ z = 0 , where the last implication follows from the assumption that Λ ′⊤ Λ ′ is full rank (rank (Λ ′ ) = d ). Because the null spaces of Λ ′⊤ and Λ ′ Λ ′⊤ are the same, their ranks should be the same as well. The same reasoning applies to ˜ Λ ′ ˜ Λ ′⊤ and ˜ Λ ′ , proving this intermediate result.

Because Λ ′ and Λ ′ Λ ′⊤ have the same rank, the column space of these two matrices must be the same as the columns of Λ ′ Λ ′⊤ are given by linear combinations of columns of Λ ′ . Same for ˜ Λ ′ and ˜ Λ ′ ˜ Λ ′⊤ . Consequently, the column spaces of Λ ′ and ˜ Λ ′ are the same.

Because the column spaces of Λ ′ and ˜ Λ ′ are the same, there must be an invertible matrix U such that ˜ Λ ′ = Λ ′ U . But then

and

Because ˜ Λ ′ = Λ ′ U , we have that

If Ψ = I d , then L = I d and M = U .

Finally, we prove that ˜ B = B ( M ⊤ ) -1 . From previous considerations, we can write

If Ψ = I d , then L = I d and ( M ⊤ ) -1 = U .

From our proof, we can see that the matrix M is dependent on the specification of Ψ .

A.1 Interpretability

In practical situations, it is hard to fix the covariance matrix of skills to something meaningful before fitting the model, as suggested in Section A.1. To make the model interpretable, we mirror a standard approach used in factor analysis, e.g. , in Chen et al. [2019]'s applications. First, we fit Sloth without any constraints on the covariance of skills obtaining the estimates ( ˆ Λ , ˆ b, ˆ B ) . Second, we find the matrix A ∈ R d × d such that the skills X ˆ BA have covariance identity, update ˆ B ← ˆ BA , and update ˆ Λ ← ˆ Λ( A ⊤ ) -1 so the model outputs remains unchanged, because ˆ Λ( X ˆ B ) ⊤ = ˆ Λ( A ⊤ ) -1 ( X ˆ BA ) ⊤ .

Third, we find a matrix M ∈ R d × d such that ˆ Λ M is easily interpretable ( e.g. , it is a sparse matrix); there are different methods to find M and, in this paper, we use the Geomin [Yates, 1987, Chen et al., 2019] oblique rotation method to find a suitable M using the Python package FactorAnalyzer [Biggs, 2019]. We then update ˆ Λ ← ˆ Λ M and, to make the model invariant, we also update ˆ B ← ˆ B ( M ⊤ ) -1 ; the resulting skills are still guaranteed to have unitary standard deviations, so their covariance equals their correlation. Finally, we standardize the columns of the skills X ˆ B to have zero mean, while keeping the correlation structure unchanged. This last step implies that ˆ b must be translated to make the model invariant.

B Compute-optimal scaling

In this section, we derive compute-optimal scaling rules for skills. Specifically, given a language model family and a particular skill, our goal is to determine the model configuration that maximizes performance under a fixed computation budget 6 st = c .

Consider a model family i with skill k defined as

Letting u = log( s ) , v = log( t ) , and l = log( c ) -log(6) , we formulate the optimization problem as:

This reduces to a simpler optimization problem in terms of u alone:

To prevent our compute-optimal scaling method from making unreasonable predictions, we further restrict its solution to the ranges of u and v observed in the training data. Hence, we impose constraints u ∈ [ u, u ] and v = l -u ∈ [ v, v ] , where bounds u, u, v, v are set based on quantiles from training data. Combining these constraints yields:

Thus, the optimization problem becomes:

which is straightforward to solve. Specifically, if β k 2 > 0 , g ik ( u ) is a concave parabola, and the maximizer is either at the vertex (if it falls within U ) or at one of the interval endpoints max( l -v, u ) or min( l -v, u ) .

C Connections with factor analysis

Sloth is heavily inspired by (exploratory) factor analysis models. Factor analysis is a statistical technique used to identify underlying relationships between observed variables by reducing the data's

dimensionality [Bishop and Nasrabadi, 2006, Chen et al., 2019]. It assumes that multiple observed variables are influenced by a smaller number of unobserved/latent variables called factors (skills θ ( i ) , in our case). These factors help explain the correlations among the observed variables. The method aims to model the observed variability and reveal the structure behind the data by estimating the factor loadings ( Λ , in our case). The classical model assumes

where Y i is a vector of variables of interest and ε i is an error term. There are versions for the factor model in which a nonlinear model for Y i is assumed, e.g. , in item response theory (IRT) [Reckase, 2006, Chen et al., 2019]. It is usually the case that θ i is estimated using a random effects model, i.e. , practitioners place a prior distribution on θ i . In our work, we assume θ i is given by a function of observable covariates and a family-specific intercept, which is fitted using data.

D Motivating the interaction term in Sloth

As shown in Section 3, we include an interaction term between log( s ) and log( t ) . In the first place, we consider this as a natural extension of the model that depends on s and t only through FLOPs, since we recover that formulation if β k 1 = β k 2 and β k 3 = 0 . In the second place, we believe that the dependence of benchmark performances on log( s ) depends on log( t ) (and possibly vice-versa). To motivate this idea we show some plots for two benchmarks we use: MMLU-PRO and BBH. For these plots, we only keep families with a higher number of models. First, realize that in both Figures 8 and 9, the performance within families in the middle plot can be well approximated by a line. Also, the slope of this line has a strong relation with the number of tokens in the last plots. For example, Pythia was trained in a small dataset and its (hypothetical) slopes on the second plot are almost zero in both cases. On the other hand, Qwen2 was trained on more data and its (hypothetical) slope on the middle plots is high. Certainly, this relationship does not always exist, but adding an interaction term in our model helps us to leverage this pattern when it exists.

Family

score

0.5

score

0.5

score

0.5

bloom

llama

Ilama-2

S

0.4

S

0.4

S

0.4

PRO

PRO

PRO

pythia

ILU-F

P

0.3

P

0.3

P

0.3

qwen1.5

MMI

0.2

M

M

0.2

M

M

0.2

starcoder2

smollm

yi

0.1

0.1

0.1

yi-1.5

0.0

2.5

5.0

7.5

-2

0

2

4

-1

0

1

2

log FLOPs

Family

0.6-

0.6

0.6

bloom

Ilama

score

ore

ore

Ilama-2

0.5

SCO

0.5

SCOI

0.5

pythia

S

S

S

qwen1.5

B

B

三

三

B

B

0.4

B

0.4

B

0.4

smollm

starcoder2

yi

0.3

0.3

0.3

yi-1.5

0.0

2.5

5.0

7.5

-2

0

2

4

1

0

1

2

log FLOPs

E PCA approach formulation

We follow the ideas of Ruan et al. [2024] as closely as possible to create a prediction method. Moreover, we follow their code 6 and apply PCA with the same set of hyperparameters. Assume we have a matrix of scores Y ∈ [0 , 1] n × J in which columns represent benchmarks and each row represents a language model. We compute the covariance matrix of benchmark scores using Y and then compute its eigenvector matrix U , where the columns give the ordered eigenvectors (from the highest eigenvalue to the lowest one). To reduce the dimensions of Y , we keep only the first d columns of Y U , resulting in ˜ Y ∈ R n × d . For each column of ˜ Y (principal components; PCs), we train a linear regression model using logFLOPs as the covariate; in this case, either the intercept or both the intercept and slope can be family-dependent. At test time, we predict the PCs of a held-out model and then go back to the original coordinate axis to obtain the final predictions by computing ∑ d j =1 ˆ PC j U · ,j ∈ R J .

F Sloth is parameter-efficient: parameter count analysis

When the number of model families f is moderately large, Sloth actually uses fewer parameters than the top-performing baselines (both of which consider family-specific intercept or train the activation function). This is because of the assumed latent skill structure of Sloth . For example, with d = 3 and we use J = 12 benchmarks:

Sloth : 12 · ( d +2) + d · ( f +3) = 69 + 3 f parameters

'FLOPs' baseline: 12 · ( f +3) = 36 + 12 f parameters

'Size and Tokens' baseline: 12 · ( f +5) = 50 + 12 f parameters

So for f ≥ 4 , Sloth uses fewer parameters than either baseline.

G Models in our dataset

8b-instruct instruct

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

llama-30b llama-65b

llama-7b meta-llama-3-70b

meta-llama-3-70b- instruct

meta-llama-3-8b meta-llama-3-8b-

instruct mpt-30b

mpt-30b-chat mpt-30b-instruct

mpt-7b-instruct olmo-1b

olmo-7b open_llama_13b

open_llama_3b open_llama_3b_v2

open_llama_7b open_llama_7b_v2

openhermes-13b openhermes-7b

opt-1.3b opt-125m

opt-13b opt-2.7b

opt-30b opt-350m

opt-6.7b opt-66b

orca-2-13b orca-2-7b

orca_mini_v3_13b orca_mini_v3_70b

orca_mini_v3_7b orca_mini_v7_72b

orca_mini_v7_7b pythia-1.4b

pythia-12b pythia-160m

pythia-1b pythia-2.8b

pythia-70m qwen-14b

qwen-72b qwen-7b

qwen1.5-0.5b qwen1.5-0.5b-chat

qwen1.5-1.8b qwen1.5-1.8b-chat

qwen1.5-14b qwen1.5-14b-chat

qwen1.5-32b qwen1.5-32b-chat

qwen1.5-4b qwen1.5-4b-chat

qwen1.5-72b qwen1.5-72b-chat

qwen1.5-7b qwen1.5-7b-chat

qwen2-0.5b qwen2-0.5b-instruct

qwen2-1.5b qwen2-1.5b-instruct

qwen2-72b qwen2-72b-instruct

qwen2-7b qwen2-7b-instruct

rwkv-4-14b-pile rwkv-4-169m-pile

rwkv-4-1b5-pile rwkv-4-3b-pile

rwkv-4-430m-pile rwkv-4-7b-pile

sauerkrautlm- gemma-2b

llama llama

llama meta-llama-3

meta-llama-3- instruct

meta-llama-3

meta-llama-3- instruct

mpt mpt-chat

mpt-instruct mpt

mpt-chat mpt-instruct

olmo olmo

open_llama_

open_llama_

open_llama__v2

open_llama_

open_llama__v2

openhermes openhermes

opt opt

opt opt

opt opt

opt opt

orca-2

orca-2

orca_mini_v3_

orca_mini_v3_

orca_mini_v3_

orca_mini_v7_

orca_mini_v7_

qwen qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen1.5

qwen1.5-chat qwen2

qwen2-instruct qwen2

qwen2-instruct qwen2

qwen2-instruct qwen2

qwen2-instruct rwkv-4-pile

rwkv-4-pile rwkv-4-pile

rwkv-4-pile rwkv-4-pile

rwkv-4-pile sauerkrautlm-

gemma llama

llama llama

meta-llama-3

meta-llama-3

meta-llama-3

meta-llama-3

mpt mpt

mpt mpt

mpt mpt

olmo olmo

openllama openllama

openllamav2

openllama openllamav2

llama-2

llama-2

opt opt

opt opt

opt opt

opt opt

llama-2

llama-2

llama-2

llama-2

llama-2

qwen qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

qwen1.5

rwkv rwkv

rwkv rwkv

rwkv rwkv

False

False

False

True

True

True

True

True

True

True

True

True

True

True

True

False

False

False

False

False

False

False

True

True

True

True

True

True

True

True

False

False

False

False

False

False

False

True

True

True

True

True

True

True

True

False

False

False

False

False

False

False

False

False

False

False

False

False

False

False

False

False

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

False

True

False

False

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

False

True

False

True

False

True

False

True

True

True

True

True

True

True

False

True

True

True

True

True

True

False

False

False

False

False

False

True

True

False

False

False

False

False

True

True

True

False

False

False

True

False

False

False

True

True

True

True

True

True

True

False

True

True

False

True

True

True

False

False

False

False

True

True

True

True

True

True

True

True

True

True

False

False

True

True

True

True

True

True

True

True

True

True

False

False

False

False

False

False

True

True

True

True

True

True

True

True

True

False

False

True

False

False

False

False

False

False

False

False

False

False

False

True

True

True

True

True

True

True

True

False

False

False

False

False

False

False

True

True

True

True

True

True

True

True

True

True

True

True

False

True

False

True

False

True

False

True

False

True

True

True

False

False

False

False

False

False

False

False

False

False

False

False

False

False

False

False

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

sauerkrautlm- gemma-7b

instruct smollm-135m

smollm-135m- instruct

smollm-360m smollm-360m-

instruct stablelm-base-

alpha-3b stablelm-base-

alpha-7b starcoder2-15b

starcoder2-3b starcoder2-7b

starcoderbase starcoderbase-1b

starcoderbase-3b starcoderbase-7b

wizardlm-13b-v1.0

wizardlm-70b-v1.0

yi-1.5-34b yi-1.5-34b-chat

yi-1.5-6b yi-1.5-6b-chat

yi-1.5-9b yi-1.5-9b-chat

yi-34b yi-34b-200k

yi-34b-chat yi-6b

yi-6b-200k yi-6b-chat

yi-9b sauerkrautlm-

gemma smollm

smollm- instruct

smollm smollm-

instruct smollm

smollm- instruct

stablelm-base- alpha

stablelm-base- alpha

starcoder2

starcoder2

starcoder2

starcoderbase starcoderbase

starcoderbase starcoderbase

wizardlm-v1.0

wizardlm-v1.0

xglm xglm

xglm xglm

yi-1.5

yi-1.5-chat yi-1.5

yi-1.5-chat yi-1.5

yi-1.5-chat yi

yi-200k yi-chat

yi yi-200k

yi-chat yi

gemma smollm

smollm smollm

smollm smollm

smollm stablelm

stablelm starcoder2

starcoder2

starcoder2

starcoder starcoder

starcoder starcoder

llama-2

llama-2

xglm xglm

xglm xglm

yi-1.5

yi-1.5

yi-1.5

yi-1.5

yi-1.5

yi-1.5

yi yi-200k

yi yi

yi-200k yi

yi

True

True

True

True

True

True

True

True

True

True

True

True

False

False

False

False

False

False

True

True

True

True

True

True

True

True

True

True

False

False

False

False

False

False

False

True

False

False

False

False

False

False

True

True

True

True

True

True

True

True

True

False

False

True

True

True

True

True

True

True

True

True

True

True

True

True

True

True

False

True

True

True

True

True

True

True

True

False

False

True

True

True

False

False

False

False

True

True

False

False

False

False

True

True

True

True

True

True

True

False

False

True

False

True

True

False

False

False

False

False

False

False

False

False

True

True

True

True

True

True

True

False

False

True

True

True

True

False

False

False

False

False

False

True

False

False

True

False

False

False

H Extra performance prediction results

In this section, we present the full versions of the figures presented in the main text and some other extra results.

H.1 Mean Absolute Percentage Error (MAPE) plot

MMLU

ARC

Winogrande

TruthfulQA

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

22.7

14.1

11.7

7.9

14.5

78.5

24.9

14.2

6.3

4.4

3.2

22.6

32.9

13.9

19.5

7.4

6.1

3.8

9.9

36.9

13.9

23.0

12.2

11.2

6.7

10.8 211.1 45.8

23.1

6.6

5.9

3.0

10.2 287.6 56.1

26.4

6.6

6.7

2.8

14.0 247.6 50.7

25.2

6.8

6.8

2.9

14.7 252.1 51.4

15.4

14.1

14.9

7.5

14.6

51.9

19.7

15.4

8.5

10.5

5.0

10.0

84.2

22.3

11.4

8.1

9.5

4.8

12.0

41.9

14.6

11.2

9.9

9.8

4.7

11.0

37.8

14.1

19.5

6.8

7.0

3.7

10.3

57.0

17.4

9.7

6.2

6.7

4.2

9.0

41.1

12.8

10.4

6.4

6.4

4.1

11.3

37.3

12.6

11.2

6.2

5.8

3.8

9.4

31.7

11.3

Open LLM Leaderboard v1

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

32.3

10.0

71.9

8.4

7.0

25.6

25.9

16.3

8.3

54.3

8.2

11.3

19.5

19.6

17.2

9.9

59.6

9.9

7.0

42.1

24.3

31.6

18.8 176.2

8.7

8.2

56.0

49.9

20.6

19.4 173.3

8.8

7.4

58.1

47.9

20.7

18.5 230.6

8.9

6.8

56.7

57.0

20.6

18.5 240.6

8.9

9.7

54.9

58.9

22.7

14.2

74.0

7.1

5.8

37.1

26.8

17.1

9.3

70.1

6.9

4.9

26.9

22.5

16.9

10.1

60.2

6.9

7.6

28.0

21.6

16.8

12.2

67.4

6.9

8.2

28.4

23.3

31.7

10.2

75.3

6.0

4.9

21.9

25.0

16.5

5.8

71.8

8.3

5.5

10.7

19.8

16.2

6.0

54.9

7.6

10.5

12.6

18.0

16.0

5.5

91.5

6.3

7.2

16.8

23.9

Open LLM Leaderboard v2

H.2 Test families have exactly one model in the training set

H.2.1 Average prediction loss across models

MMLU

ARC

Winogrande

TruthfulQA

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.4

6.2

7.1

5.2

6.4

12.4

7.8

6.5

3.0

3.0

2.2

9.0

5.7

4.9

7.1

3.2

3.8

2.6

4.5

5.2

4.4

8.7

5.6

7.5

4.7

4.5

13.1

7.3

8.7

3.1

4.2

2.1

4.3

13.8

6.0

10.0

3.2

4.8

2.0

6.0

12.1

6.3

9.7

3.2

4.9

2.0

6.2

12.2

6.4

9.1

6.9

7.6

5.7

5.5

11.5

7.7

9.5

6.4

6.9

5.0

4.6

10.4

7.1

9.6

6.4

7.0

5.1

6.1

9.9

7.3

9.6

6.4

7.0

5.1

6.2

9.8

7.3

8.9

6.3

8.2

5.7

5.5

11.7

7.7

8.0

5.7

6.6

5.4

5.3

11.0

7.0

8.0

5.9

6.6

5.6

4.9

11.3

7.1

8.4

5.6

6.7

5.5

4.7

11.4

7.0

8.3

6.8

9.8

5.3

6.5

13.5

8.4

7.4

4.1

6.8

3.5

4.2

9.1

5.8

5.8

3.9

6.1

3.4

5.4

7.4

5.3

5.7

4.6

6.3

3.2

5.0

5.9

5.1

8.2

3.1

4.4

2.5

4.4

11.0

5.6

4.4

2.7

4.2

2.9

3.8

7.7

4.3

4.8

2.8

4.0

2.8

4.9

6.3

4.2

5.3

2.7

3.6

2.6

4.2

5.9

4.1

Open LLM Leaderboard v1

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.4

4.5

4.2

2.6

2.8

5.6

4.9

5.1

3.6

2.6

2.5

4.4

4.5

3.8

4.9

3.8

3.3

3.0

2.8

6.8

4.1

9.3

7.3

4.4

2.7

3.2

9.4

6.0

6.1

7.4

4.3

2.7

2.8

9.3

5.4

6.1

7.1

5.3

2.7

2.6

9.1

5.5

6.1

7.1

5.5

2.7

3.7

8.9

5.7

10.5

5.1

5.2

2.8

2.8

6.2

5.4

11.3

5.0

5.5

3.0

3.0

5.6

5.6

11.2

5.1

5.6

3.1

2.9

5.5

5.6

11.3

5.2

5.6

3.0

3.0

5.4

5.6

10.0

4.9

3.4

2.5

3.9

5.6

5.0

10.2

4.2

3.0

2.3

2.4

5.0

4.5

10.2

3.4

3.1

2.1

3.3

5.3

4.6

10.1

3.4

3.5

2.2

3.6

5.2

4.7

9.2

6.0

3.8

2.3

2.3

7.5

5.2

4.8

4.1

3.2

2.2

1.9

5.6

3.6

4.8

4.3

2.9

2.2

3.0

5.7

3.8

4.8

5.0

3.8

2.2

3.3

5.9

4.2

9.9

4.2

2.6

1.9

2.0

4.2

4.1

4.9

2.6

2.3

2.5

2.2

2.6

2.9

4.8

2.5

4.1

2.4

4.0

3.1

3.5

4.8

2.4

4.3

2.0

2.9

3.5

3.3

Open LLM Leaderboard v2

Open LLM Leaderboard v1/v2

MMLU

ARC

Winogrande

TruthfulQA

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.7

5.1

5.4

4.3

6.6

11.4

7.9

5.3

4.8

2.7

2.6

7.5

6.1

5.6

3.9

2.6

2.7

7.1

5.3

4.2

3.5

2.2

2.2

4.7

5.4

4.1

4.8

3.7

3.1

2.5

4.8

6.4

4.1

2.2

6.6

2.2

2.6

6.3

4.1

11.5

6.1

7.9

4.8

4.9

14.7

7.2

4.5

3.3

2.1

2.7

5.9

6.3

11.2

5.1

5.2

3.4

5.2

15.3

7.2

4.4

2.9

2.2

2.7

5.9

5.9

11.0

4.5

4.1

2.5

5.3

15.0

5.7

4.4

3.0

2.1

2.8

6.0

5.6

12.0

4.5

4.4

2.3

6.3

13.3

3.9

5.9

3.1

2.4

2.9

7.5

5.7

9.9

5.7

5.5

4.7

6.4

11.8

7.9

5.5

5.3

2.6

3.0

8.0

6.4

9.2

6.1

5.7

3.8

6.8

9.8

7.9

5.7

5.6

2.8

3.1

7.6

6.2

9.1

6.4

5.8

3.8

6.7

8.2

7.6

6.3

6.3

3.0

3.4

7.8

6.2

9.1

6.4

5.8

3.8

6.8

8.3

7.6

6.3

6.4

3.3

3.7

7.8

6.3

8.0

5.2

6.7

4.7

5.9

10.7

7.8

4.5

3.2

2.3

3.1

6.7

5.7

8.2

4.7

4.9

3.8

5.2

9.9

8.1

4.3

10.5

2.6

2.4

7.5

6.0

7.4

4.7

4.9

4.1

5.6

9.8

8.6

4.0

3.2

2.4

2.2

6.9

5.3

8.0

5.0

4.8

4.2

5.4

9.4

8.1

3.8

3.0

2.2

2.2

6.0

5.2

11.3

7.0

7.7

5.6

6.6

15.9

8.6

5.0

3.0

2.3

2.4

6.7

6.8

7.9

5.8

6.0

3.9

4.4

8.9

8.4

3.3

2.0

2.2

1.9

4.7

4.9

7.5

5.8

6.1

3.8

4.6

8.6

4.0

3.4

2.3

1.9

2.2

4.3

4.5

6.7

6.0

6.2

3.8

8.4

7.1

3.9

4.0

2.3

1.8

4.1

4.3

4.9

8.6

5.1

7.2

5.3

4.3

12.3

6.7

2.8

2.9

2.0

1.7

4.4

5.3

5.8

3.8

5.0

3.3

5.1

7.5

7.2

2.6

2.2

2.2

1.9

3.3

4.2

5.4

3.0

4.4

3.1

5.0

6.4

4.7

2.5

1.6

2.2

1.5

2.5

3.5

5.4

4.0

5.0

2.9

6.5

6.8

4.1

1.8

2.8

2.1

3.8

3.8

4.1

H.2.2 Family-specific prediction losses

Open LLM Leaderboard v1 (Average error across benchmarks)

bloom

codegen-nl

codellama

deepseek-coder-base

pythia

falcon

gpt-j-neo-neox

meta-llama-3

mpt

olmo

opt

rwkv-4-pile

starcoder2

stablelm-base-alpha

xglm

yi-1.5

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

5.3

2.6

12.2

13.1

2.6

9.1

8.0

2.4

12.3

10.5

4.0

7.3

3.9

9.8

2.4

13.8

12.7

5.1

11.0

4.4

2.9

6.4

6.9

5.1

9.1

9.1

7.8

3.9

2.9

4.6

0.8

6.9

8.7

4.0

3.2

1.3

3.0

2.3

2.8

2.8

5.3

6.7

7.7

6.2

6.9

5.6

2.4

3.3

4.9

4.6

6.5

5.2

1.3

6.9

1.2

2.0

1.8

5.3

6.6

8.0

4.7

7.9

10.2

10.8

8.8

5.3

6.3

8.5

7.9

9.4

12.7

6.6

7.3

2.7

4.8

5.3

5.4

2.2

7.1

3.1

6.7

9.2

10.2

8.5

4.4

6.2

3.6

4.1

9.4

13.6

6.4

4.5

2.0

4.7

3.5

5.5

1.7

7.0

3.4

7.5

11.2

10.5

9.5

3.4

6.4

4.7

2.9

10.3

13.9

6.9

4.5

2.0

5.3

3.9

5.6

2.3

7.0

3.9

7.6

11.1

10.6

9.7

3.0

5.8

4.6

2.9

10.4

14.4

7.0

4.2

2.1

5.3

3.8

6.6

2.8

12.5

13.0

3.0

8.6

6.4

2.6

12.2

9.6

4.1

8.1

4.0

8.7

2.6

14.0

12.5

4.5

10.5

4.5

1.7

11.9

12.1

2.2

8.1

6.9

2.3

12.1

9.8

3.2

9.2

3.5

5.6

2.1

13.0

12.9

4.9

9.4

4.9

1.7

13.0

12.5

1.8

8.6

6.8

2.3

11.9

13.6

2.7

9.2

3.2

5.3

2.1

13.1

12.8

4.9

9.2

5.0

1.7

13.0

12.5

1.8

8.6

6.8

2.3

11.9

13.6

2.6

9.2

3.2

5.3

2.1

13.1

12.8

4.9

9.2

2.5

4.6

15.3

15.1

2.3

9.8

5.7

3.0

6.4

7.4

5.1

10.9

4.8

9.7

2.3

14.7

14.2

5.6

6.6

3.6

3.1

14.8

14.7

1.8

6.2

5.9

2.4

10.5

5.3

2.2

9.1

2.3

6.9

1.7

16.4

15.5

4.8

5.7

3.1

2.6

14.4

14.9

1.5

6.5

6.3

2.3

11.7

5.8

2.1

10.0

2.2

6.9

1.5

17.0

14.7

4.7

6.1

3.3

2.7

14.9

14.9

1.5

6.7

6.1

2.1

11.7

5.3

2.5

10.4

2.2

5.5

1.7

16.8

15.3

4.9

5.6

5.8

3.1

10.4

12.3

7.2

5.4

12.6

8.5

8.3

5.6

3.9

3.9

5.9

32.9

6.1

14.9

3.5

4.6

4.1

3.5

3.2

8.3

6.5

7.3

13.2

7.4

7.6

4.4

5.2

6.7

2.0

5.7

10.1

6.1

5.1

1.6

3.6

3.3

3.2

2.6

6.5

9.1

6.0

10.2

8.9

6.0

5.0

6.8

5.9

1.9

3.0

10.4

4.5

4.0

1.5

2.9

3.0

4.4

2.3

6.8

6.6

6.1

9.0

8.9

6.6

4.8

5.0

5.0

1.9

3.4

9.9

5.1

3.9

2.0

3.0

2.7

3.2

4.2

8.8

9.6

7.2

6.4

6.9

2.1

3.9

4.8

3.6

10.5

2.5

12.5

2.3

11.8

1.1

2.0

2.9

2.4

4.2

5.8

10.2

7.7

8.3

6.6

1.9

3.0

3.1

6.5

2.7

2.0

3.7

1.9

5.5

1.6

2.2

2.2

2.8

2.1

5.3

9.5

7.6

6.8

6.6

5.4

3.6

4.6

4.0

2.6

2.0

4.7

1.3

7.3

1.2

1.8

1.7

2.2

3.5

6.0

10.2

7.4

6.5

6.1

1.3

3.5

3.7

5.1

2.6

2.0

5.8

1.3

5.1

0.9

1.7

2.1

Open LLM Leaderboard v2 (Average error across benchmarks)

bloom

pythia

falcon

gpt-j-neo-neox

meta-llama-3

olmo

opt

starcoder2

smollm

yi-1.5

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

2.4

1.4

4.0

7.1

1.4

14.6

4.2

2.4

6.2

4.8

1.4

8.3

2.3

4.0

3.9

3.5

1.3

4.3

2.5

5.3

9.0

1.5

3.3

4.5

2.9

4.1

4.0

4.3

0.8

4.1

3.0

4.5

7.6

3.3

6.3

3.9

4.1

8.0

1.9

8.2

2.9

8.1

5.0

10.2

9.6

2.2

6.7

5.3

5.2

8.2

1.9

6.0

2.3

4.8

5.0

10.1

8.5

2.1

6.9

3.9

5.2

8.3

2.3

5.6

2.4

4.8

5.1

10.3

8.3

2.3

7.1

4.0

5.5

8.8

2.5

5.4

2.5

5.3

5.6

9.9

8.6

2.2

7.4

4.2

2.3

1.8

3.3

6.9

1.8

21.0

4.1

1.8

6.5

4.7

2.1

8.8

2.2

2.2

3.3

6.9

1.7

20.5

4.2

3.8

6.3

5.1

1.7

8.7

2.2

2.2

3.1

7.3

1.8

20.6

4.2

3.7

6.4

5.1

1.7

8.6

2.2

2.2

3.1

7.4

1.8

20.6

4.2

3.7

6.4

5.1

1.7

8.7

2.0

1.1

2.3

7.9

1.3

16.9

4.4

1.1

6.0

8.5

1.3

7.8

2.2

1.1

2.4

8.0

1.2

12.6

4.0

1.2

6.4

6.3

1.2

7.6

2.1

1.3

1.6

8.0

1.2

11.1

4.1

1.1

6.4

8.9

1.2

7.6

2.1

1.2

1.8

9.2

1.2

12.2

4.1

1.2

6.5

7.6

1.2

7.6

1.3

4.8

4.4

8.9

1.6

11.4

2.1

5.3

11.3

3.5

2.4

5.3

3.0

3.0

3.6

5.7

1.4

4.1

1.9

2.7

10.2

1.7

2.2

4.2

3.1

3.0

4.0

5.7

1.5

4.4

2.5

3.5

9.8

1.5

2.5

4.6

2.9

2.9

4.1

5.8

1.5

6.4

2.6

5.0

10.1

1.8

2.3

4.6

2.1

1.2

4.7

6.5

1.1

8.1

5.0

1.3

7.7

4.2

2.3

5.3

3.0

1.3

4.2

4.2

1.2

4.8

0.7

0.9

5.0

3.4

1.6

3.9

2.5

1.2

5.0

3.6

2.0

5.1

1.8

1.6

8.3

5.0

1.2

4.7

2.0

1.4

4.3

4.3

0.9

5.0

3.4

1.3

8.4

2.9

1.6

4.1

bloom

pythia

falcon

gpt-j-neo-neox

meta-llama-3

olmo

opt

starcoder2

yi-1.5

FLOPs (shared

intercept)

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

2.2

3.0

4.8

4.9

1.4

14.4

6.9

4.2

7.0

9.2

9.2

2.4

5.3

6.7

6.5

1.2

3.9

1.5

5.1

6.9

2.4

3.4

2.0

4.0

6.8

5.0

1.6

4.0

3.3

3.4

6.3

5.3

3.4

5.2

8.8

6.1

6.5

3.1

7.2

5.7

9.1

8.6

4.7

4.3

4.2

8.1

5.4

6.2

2.8

8.0

5.0

9.2

9.1

2.8

4.0

4.1

8.2

4.5

6.0

2.0

6.3

5.0

9.4

9.2

2.8

3.6

5.1

9.5

4.8

6.1

2.5

5.2

4.3

9.3

9.2

3.0

3.8

2.3

2.9

5.1

4.9

1.7

17.2

6.7

4.1

6.9

9.1

9.2

2.5

2.5

3.1

5.1

1.9

18.0

7.0

4.4

5.5

8.9

8.9

2.4

2.6

2.5

5.1

1.6

19.9

6.9

4.5

5.2

8.8

8.8

2.4

2.6

2.5

5.1

1.5

20.5

6.9

4.5

5.3

8.8

8.9

2.6

2.4

7.7

5.9

2.2

8.3

7.7

3.0

6.2

9.8

7.2

2.5

2.0

5.3

6.7

1.3

15.2

6.4

2.1

5.6

12.7

6.4

2.6

2.3

4.2

5.9

1.1

6.8

6.9

2.3

6.6

12.7

7.0

2.6

2.4

3.9

6.2

1.1

7.5

6.8

2.4

5.7

11.2

7.1

3.9

4.6

5.6

7.9

2.5

5.3

3.2

4.6

23.5

10.0

4.2

2.9

4.8

7.2

7.3

1.8

7.1

1.7

5.6

8.6

2.9

4.2

3.0

4.3

7.3

7.2

1.6

4.8

1.9

4.8

8.6

2.9

3.6

3.9

5.7

7.7

6.4

1.9

6.0

1.7

6.1

7.8

2.8

3.7

3.7

3.7

6.2

6.8

1.2

5.4

6.1

3.7

9.0

8.2

4.0

4.5

1.7

8.2

6.0

1.2

5.7

2.3

1.5

6.8

4.6

3.5

2.1

3.3

7.6

5.0

1.3

3.7

2.4

1.4

4.3

3.7

3.7

5.6

4.8

6.8

4.3

2.2

3.5

2.1

1.1

5.5

5.7

3.4

Open LLM Leaderboard v1/v2 (Average error across benchmarks)

H.3 Test families have exactly two models in the training set

H.3.1 Average prediction loss across models

MMLU

ARC

Winogrande

TruthfulQA

Average

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

9.2

7.9

5.5

5.0

8.8

20.0

9.4

7.5

3.1

3.4

1.9

5.6

7.9

4.9

10.8

9.0

13.1

7.2

5.5

13.8

9.9

10.8

8.3

12.2

6.0

5.2

12.8

9.2

11.7

8.4

11.6

6.0

5.0

12.2

9.2

12.7

8.3

11.3

5.8

8.1

12.1

9.7

8.4

6.0

7.2

5.5

6.6

9.7

7.2

7.6

6.1

6.5

4.7

4.8

8.8

6.4

7.7

6.2

6.5

4.9

6.4

7.5

6.5

7.6

6.2

6.6

4.9

6.3

7.3

6.5

8.9

5.2

6.9

5.5

7.7

13.1

7.9

8.0

5.2

5.9

4.9

6.3

10.9

6.9

7.7

5.6

5.8

4.9

5.8

10.8

6.8

8.0

5.1

5.7

4.6

5.8

11.5

6.8

11.9

6.4

7.9

4.8

5.3

19.1

9.2

5.3

4.9

6.9

3.3

4.1

10.2

5.8

4.9

4.8

6.0

3.1

5.6

8.6

5.5

4.5

5.1

5.9

3.1

5.0

7.4

5.2

8.5

4.2

5.5

4.0

5.3

14.8

7.0

4.0

2.8

3.6

2.2

5.1

6.9

4.1

4.7

3.2

3.5

1.9

4.3

7.5

4.2

5.0

3.0

3.3

2.0

4.9

8.0

4.3

Open LLM Leaderboard v1

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

13.9

7.4

26.6

4.8

9.8

8.6

11.9

7.1

2.2

4.6

4.2

3.9

1.8

4.0

9.0

8.1

4.1

1.7

3.9

8.2

5.8

11.3

6.8

4.5

1.4

3.5

6.0

5.6

11.2

7.0

3.3

1.4

3.8

6.1

5.5

11.2

6.9

3.2

1.3

10.6

6.5

6.6

9.2

5.1

5.0

2.4

3.3

4.9

5.0

9.5

5.2

6.0

2.5

3.3

5.1

5.3

9.2

5.2

5.9

2.7

4.1

5.0

5.4

9.2

5.2

5.9

2.8

4.0

4.8

5.3

9.6

5.3

4.3

2.4

3.3

4.7

4.9

9.3

5.1

4.5

2.6

3.4

4.9

5.0

9.5

5.1

4.5

2.5

3.6

4.9

5.0

9.4

4.8

4.2

2.5

3.6

4.8

4.9

8.3

5.7

3.3

1.4

3.2

5.0

4.5

4.9

4.8

3.2

1.4

3.2

4.5

3.7

4.8

4.6

6.4

2.0

3.6

4.2

4.3

4.7

3.9

6.8

2.5

3.1

4.7

4.3

8.1

4.4

7.9

1.5

2.8

4.3

4.8

5.1

4.3

8.2

2.0

2.8

2.3

4.1

6.7

2.4

3.8

1.7

5.4

1.8

3.6

5.8

2.1

5.1

1.6

3.3

1.6

3.2

Open LLM Leaderboard v2

Open LLM Leaderboard v1/v2

MMLU

ARC

Winogrande

TruthfulQA

IFEval

BBH

MATH Lvl 5

GPQA

MUSR

MMLU-PRO

Average

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

8.4

7.1

4.7

4.9

10.0

27.3

15.2

8.1

24.2

5.8

8.6

9.0

11.1

3.2

3.1

3.3

3.2

7.1

12.2

5.8

4.7

8.6

4.3

3.4

3.9

5.2

14.5

10.1

12.5

7.6

6.5

19.8

12.1

7.1

4.0

1.9

2.2

7.5

8.8

15.1

8.6

10.3

5.6

6.2

19.7

10.8

7.2

4.1

2.0

2.2

7.6

8.3

14.7

9.6

12.8

7.0

6.7

20.1

7.9

6.8

3.5

1.8

3.0

7.2

8.4

13.6

9.8

12.7

6.9

7.1

20.6

10.3

7.2

3.8

2.0

3.1

6.3

8.6

7.1

5.8

7.7

6.0

6.8

10.6

7.9

5.5

5.3

2.4

2.3

6.4

6.2

6.9

4.9

5.9

4.2

7.1

10.2

8.4

5.2

6.5

2.7

2.5

5.9

5.9

6.8

5.4

5.7

4.1

6.7

10.2

8.7

5.3

8.0

2.9

2.8

5.7

6.0

6.8

5.3

5.6

4.1

6.7

10.3

8.7

5.3

7.4

2.8

2.9

5.7

6.0

5.7

6.3

8.1

5.7

6.8

11.9

9.3

4.8

5.5

3.1

2.7

6.3

6.4

6.6

3.8

4.8

3.6

6.8

15.7

9.1

4.8

5.3

2.3

2.7

6.0

6.0

5.9

4.0

5.2

3.8

7.2

14.5

10.3

4.6

5.2

3.5

2.8

6.2

6.1

5.7

3.9

5.2

3.9

6.0

11.6

10.0

4.9

4.9

3.2

2.8

5.8

5.7

7.8

4.9

6.9

4.6

5.4

17.9

8.3

6.8

5.7

1.8

2.8

7.6

6.7

5.4

5.8

7.8

4.3

5.8

12.7

8.7

5.0

4.4

1.5

2.2

4.9

5.7

4.9

5.4

7.3

3.8

6.3

12.0

6.1

4.9

4.9

1.5

2.6

4.6

5.4

3.0

5.8

5.8

3.2

6.8

10.7

4.2

5.2

6.5

1.8

2.9

4.3

5.0

3.1

6.7

9.7

6.4

4.7

16.7

8.6

4.8

6.4

1.9

2.5

3.9

6.3

5.9

3.1

3.0

2.1

4.9

14.9

8.2

4.1

3.6

1.9

1.9

4.0

4.8

3.1

4.8

3.4

3.2

5.6

8.0

7.0

3.5

2.9

2.1

2.2

2.3

4.0

2.3

2.7

2.4

1.9

6.2

9.5

5.5

4.6

4.1

2.3

3.6

2.5

4.0

H.3.2 Family-specific prediction losses

bloom

codellama

deepseek-coder-base

falcon

gpt-j-neo-neox

llama-2

open_llama_

opt

pythia

qwen1.5

rwkv-4-pile

starcoder2

xglm

yi-1.5

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

6.5

13.3

10.1

20.3

2.9

8.8

4.5

11.9

8.9

10.6

18.5

7.9

7.9

2.1

6.5

5.2

6.9

11.9

7.2

2.0

4.2

3.5

5.7

3.1

9.0

6.0

1.4

3.8

1.3

1.8

5.2

9.0

6.4

17.2

5.5

4.4

9.3

6.9

4.7

7.2

46.1

4.9

8.4

2.3

10.9

4.5

9.3

5.1

18.5

4.4

5.5

4.0

7.0

4.3

6.9

45.4

3.5

8.6

2.1

9.0

4.7

9.2

4.8

20.5

3.0

5.1

4.5

6.4

4.3

9.0

43.8

2.4

8.4

2.5

8.8

5.0

11.9

4.8

18.8

2.9

8.7

4.4

6.5

4.6

9.1

46.0

2.7

8.3

2.5

9.2

6.2

10.9

14.5

11.5

3.6

5.6

6.1

5.5

3.4

8.1

5.4

3.7

13.2

3.3

7.4

4.3

11.1

13.5

12.5

2.3

4.7

4.2

3.0

1.9

7.8

3.9

2.2

14.0

4.3

6.5

4.8

11.6

14.3

13.4

2.2

4.4

4.3

3.0

1.7

7.4

5.3

2.1

13.7

4.1

5.7

4.9

11.6

14.3

12.9

2.2

4.4

4.3

3.0

1.7

7.4

4.7

2.1

13.8

4.1

5.8

4.4

12.2

19.3

12.4

3.3

7.6

7.3

6.0

2.4

9.1

8.4

2.8

12.5

4.2

6.1

3.5

12.2

15.5

12.2

2.6

4.1

4.8

2.9

2.4

7.3

6.8

2.2

15.6

4.7

6.3

3.7

12.1

16.0

12.1

2.5

4.3

4.2

2.9

1.7

7.4

6.6

1.7

15.2

4.5

6.5

4.2

12.2

16.2

12.2

2.2

4.3

4.1

2.6

1.7

7.3

6.7

1.8

15.4

4.6

6.6

4.5

12.9

8.4

8.5

4.2

5.6

5.1

5.1

6.3

21.2

23.9

5.7

17.6

3.6

5.6

3.9

9.8

6.0

7.0

3.5

6.6

4.3

3.8

7.7

10.0

4.5

5.4

7.3

2.5

4.5

3.8

8.0

4.1

9.3

3.1

5.7

4.3

3.2

6.6

10.3

6.7

4.5

6.8

2.4

3.3

3.6

8.2

4.9

5.7

2.6

4.9

4.0

3.8

6.2

10.2

5.8

4.6

7.0

2.5

3.5

3.7

5.9

8.9

9.5

2.3

7.5

5.8

4.0

7.7

20.8

6.2

2.7

14.9

2.8

3.1

2.8

4.7

5.9

5.2

2.8

6.6

3.1

2.9

3.0

7.9

5.9

2.8

4.2

1.8

2.1

2.6

6.5

11.4

3.9

2.2

2.8

4.3

2.7

3.2

8.3

4.8

2.3

3.9

1.4

2.6

2.5

7.0

11.5

3.6

1.5

4.1

3.7

2.2

2.9

8.1

5.9

2.5

5.0

1.4

3.2

Open LLM Leaderboard v1 (Average error across benchmarks)

bloom

llama-2

orca_mini_v3_

pythia

qwen1.5

smollm

starcoder2

yi-1.5

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

10.5

5.3

20.4

13.3

11.4

23.1

1.9

4.6

16.2

1.2

3.7

4.0

2.0

5.1

7.3

1.5

3.7

7.2

3.9

6.4

5.7

2.2

6.0

10.3

2.3

3.5

12.4

4.8

3.9

5.8

3.0

5.6

9.6

2.0

3.5

12.2

4.6

3.0

4.8

2.7

5.4

9.4

1.9

3.3

14.1

5.6

4.7

5.6

4.9

6.4

12.4

2.0

4.1

13.7

2.3

7.3

5.0

1.6

3.2

10.3

1.8

6.5

6.8

2.6

7.4

4.8

1.7

3.3

12.1

1.8

6.8

6.8

2.6

7.2

4.7

1.5

3.3

13.0

2.0

6.6

7.4

2.6

7.1

4.6

1.5

3.3

13.0

2.0

6.7

7.3

2.1

7.0

5.4

1.5

4.9

7.7

1.5

7.5

6.7

2.5

6.9

4.5

1.5

4.5

7.4

1.4

8.8

7.3

2.5

6.9

5.2

1.4

4.4

6.9

1.4

9.0

7.3

2.5

6.8

5.1

1.4

4.4

6.5

1.4

8.8

7.1

1.4

5.7

5.3

1.6

8.0

6.9

2.0

3.0

6.6

1.6

3.7

4.6

2.5

6.4

5.4

1.5

2.3

5.0

1.8

3.4

4.3

2.7

5.7

12.0

2.2

1.5

4.7

1.5

3.6

4.0

2.5

5.7

12.6

1.7

2.3

4.6

1.8

6.0

5.0

1.2

6.7

11.4

3.5

1.8

6.1

1.4

4.7

4.7

1.6

4.4

11.2

1.0

2.2

6.0

2.3

4.2

4.2

2.0

3.9

6.4

1.9

2.6

5.0

1.9

3.3

2.8

1.6

4.8

7.0

1.4

2.3

4.1

Open LLM Leaderboard v2 (Average error across benchmarks)

bloom

llama-2

pythia

qwen1.5

starcoder2

yi-1.5

FLOPs

Size and

Tokens

PCA + FLOPs

(d=1)

PCA + FLOPs

(d=2)

PCA + FLOPs

(d=3)

PCA + FLOPs

(d=4)

Sloth basic (d=1)

(shared intercept)

Sloth basic (d=2)

(shared intercept)

Sloth basic (d=3)

(shared intercept)

Sloth basic (d=4)

(shared intercept)

Sloth (d=1)

(shared intercept)

Sloth (d=2)

(shared intercept)

Sloth (d=3)

(shared intercept)

Sloth (d=4)

(shared intercept)

Sloth basic

(d=1)

Sloth basic

(d=2)

Sloth basic

(d=3)

Sloth basic

(d=4)

Sloth

(d=1)

Sloth

(d=2)

Sloth

(d=3)

Sloth

(d=4)

6.7

7.3

19.7

9.2

17.2

6.1

11.6

2.1

3.9

7.2

7.9

8.2

3.0

4.3

3.0

6.7

4.0

5.5

26.6

5.5

10.5

3.4

5.1

3.4

5.2

25.4

5.9

9.8

3.7

5.9

3.1

5.5

24.9

6.0

9.9

3.6

5.3

4.0

6.8

24.8

5.9

10.0

3.0

7.8

4.2

5.6

6.0

10.3

6.1

2.5

6.6

2.3

5.7

6.5

10.9

6.5

2.5

6.6

2.6

5.5

8.1

10.8

6.2

2.5

6.5

2.5

5.6

7.7

10.9

6.1

2.8

7.0

4.7

6.6

6.1

10.6

6.6

2.3

6.1

2.7

6.2

5.1

13.0

6.3

3.0

5.4

3.6

6.3

5.3

12.8

6.4

2.7

5.4

3.4

6.2

4.3

11.3

6.4

3.6

6.8

4.3

10.5

9.8

6.6

5.4

3.5

6.2

4.7

8.7

7.0

4.7

5.1

3.0

5.4

5.2

9.0

5.9

4.3

4.8

2.1

4.9

2.4

9.3

7.1

4.6

4.8

3.7

7.7

6.2

6.7

8.4

7.5

3.8

3.3

6.9

4.4

6.6

4.0

4.2

4.2

2.2

3.9

3.9

7.5

4.8

2.7

3.1

1.6

4.4

3.4

6.8

4.8

4.1

2.5

Open LLM Leaderboard v1/v2 (Average error across benchmarks)

I Extra interpretability results

I.1 Results for d = 2

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

Reasoning

Knowledge +

Instruction following

3.58

3.42

1.74

1.32

1.43

1.15

0.62

0.66

0.24

0.00

0.11

0.05

0.00

-0.07

0.28

0.49

0.44

0.58

0.27

0.31

0.69

0.81

0.82

0.25

Reasoning

Knowledge +

Instruction following

Reasoning

Knowledge +

Instruction following

1.00

0.61

0.61

1.00

0.9

0.4

0.1

0.6

1.2

Base model skill (z-score)

0.9

0.4

0.1

0.6

1.2

Instruct model skill (z-score)

Reasoning

1.6

0.8

0.0

0.7

1.5

Base model skill (z-score)

1.6

0.8

0.0

0.7

1.5

Knowledge +

Instruction following

Families

falcon

llama-2

meta-llama-3

qwen1.5

recurrentgemma

yi-1.5

0.5

0.0

0.5

1.0

1.5

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Reasoning

0.4

0.3

0.2

0.1

0.0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1.0

0.5

0.0

0.5

1.0

1.5

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Knowledge +

Instruction following

1.6

1.2

0.8

0.4

0.0

0.4

0.8

1.2

1.6

2.0

2.4

2.8

3.2

I.2 Results for d = 3

Reasoning

Knowledge

Instruction

Following

Reasoning

Knowledge

Instruction

Following

1.00

0.12

0.43

0.12

1.00

0.20

0.43

0.20

1.00

I.3 Results for d = 4

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

Reasoning

Knowledge 1

Instruction following

Knowledge 2

4.82

4.85

2.61

2.03

2.03

1.86

0.75

0.78

0.46

0.29

0.45

0.21

-1.44

-1.04

0.02

0.11

0.10

0.43

0.70

0.73

0.09

-0.04

-0.04

0.08

-0.00

-0.01

0.24

0.05

0.02

0.03

0.01

-0.22

-0.01

0.05

0.11

-0.56

0.04

-0.27

-0.02

0.15

0.16

0.20

-0.04

0.02

0.57

0.67

0.64

0.42

Reasoning

Knowledge 1

Instruction following

Knowledge 2

Reasoning

Knowledge 1

Instruction following

Knowledge 2

1.00

0.02

0.06

0.34

0.02

1.00

0.30

0.26

0.06

0.30

1.00

0.31

0.34

0.26

0.31

1.00

1.2

0.6

0.1

0.5

1.1

Base model skill (z-score)

1.2

0.6

0.1

0.5

1.1

Instruct model skill (z-score)

Reasoning

1.6

0.8

0.0

0.8

1.6

Base model skill (z-score)

1.6

0.8

0.0

0.8

1.6

Knowledge 1

2.7

1.4

0.1

1.3

2.6

Base model skill (z-score)

2.7

1.4

0.1

1.3

2.6

Instruction following

1.9

1.0

0.1

0.7

1.6

Base model skill (z-score)

1.9

1.0

0.1

0.7

1.6

Knowledge 2

Families

falcon

llama-2

meta-llama-3

qwen1.5

recurrentgemma

yi-1.5

0

1

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Reasoning

0.45

0.30

0.15

0.00

0.15

0.30

0.45

0.60

0.75

0.90

0

1

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Knowledge 1

0.6

0.4

0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

1.6

0

1

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Instruction following

0.8

0.6

0.4

0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

1.6

0

1

Size (log10  billions of parameters)

0.50

0.25

0.00

0.25

0.50

0.75

1.00

Training tokens (log10  trillions)

Knowledge 2

1.6

1.2

0.8

0.4

0.0

0.4

0.8

1.2

1.6

2.0

2.4

2.8

3.2

4

2

0

2

4

T

EQ

i

(

s

,

t

) +

c

0.0

0.2

0.4

0.6

0.8

1.0

Normalized EQ Score

Prediction

Training Data

meta-llama-3-70b-instruct

0

1

2

0.90

0.64

0.07

EQ

J Extra downstream task plots

J.1 Emotional Intelligence

J.2 Agentic Capabilities

2.00

1.75

1.50

1.25

1.00

0.75

0.50

0.25

0.00

T

AB

(

(

s

,

t

)) +

c

0.00

0.05

0.10

0.15

0.20

0.25

0.30

AgentBench Accuracy

Training Data

llama-2-70b-chat

MMLU

ARC-C

TruthfulQA

Winogrande

HumanEval

0

1

0.87

0.11

-0.25

2.09

0.44

0.17

3.29

-0.57

-0.68

-0.76

-0.67

-0.36

-0.45

0.04

0

1

1.08

-0.28

AB

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

0

1

2

3.44

3.87

1.94

1.49

1.58

1.39

0.67

0.68

0.34

0.10

0.20

0.28

0.01

-0.25

0.34

0.41

0.38

0.42

0.17

0.08

0.62

0.73

0.77

0.02

0.03

-0.00

-0.10

0.01

0.01

0.03

0.06

0.31

0.05

0.04

-0.02

0.53

K Insights from the different link functions

In this section, we visually compare Sloth considering trainable and logistic link function σ , Owen [2024]'s model ('FLOPs (shared intercept)') and our adaptation of Ruan et al. [2024]'s observational scaling law ('PCA + FLOPs') described in Appendix E. For this experiment, we study the two Open LLM Leaderboards separately and consider LLaMa-3 and Yi-1.5 families as the test families; we make this choice because both families are popular ones and the training set size is the same for all models in each family, making comparison between models possible (in the x-axis, we use model size). For LLaMA-3, we just include one model from that family in the training set and do not train a family-specific slope for PCA+FLOPs. For Yi-1.5, we include two models in the training

set and train a family-specific slope for PCA+FLOPs. In summary, we see that: (i) training the link function can produce a much more flexible scaling law that can better predict performance saturation ( e.g. , the performance of Yi-1.5 in ARC, HellaSwag etc. ), (ii) training no family-specific parameters at all ('FLOPs (shared intercept)') usually produce poor prediction results, and (iii) PCA+FLOPs often produces flatter curves that underestimate the performance of bigger models, e.g. , see Yi-1.5 in TruthfulQA, GSM8k, and MMLU.

10 0

10 1

10 2

0

50

10 0

10 1

10 2

50

75

MMLU

10 0

10 1

10 2

40

60

80

TruthfulQA

10 0

10 1

10 2

Size (billions of parameters)

40

60

80

ARC

10 0

10 1

10 2

Size (billions of parameters)

60

80

100

10 0

10 1

10 2

Size (billions of parameters)

60

80

Winogrande

Family: meta-llama-3

train

test

Sloth basic

(d=3)

Sloth

(d=3)

FLOPs

(shared intercept)

PCA+FLOPs

(d=3)

10 0

10 1

10 2

0

20

40

MATH Lvl 5

10 0

10 1

10 2

30

40

GPQA

10 0

10 1

10 2

25

50

MMLU-PRO

10 0

10 1

10 2

Size (billions of parameters)

40

60

80

BBH

10 0

10 1

10 2

Size (billions of parameters)

40

50

MUSR

10 0

10 1

10 2

Size (billions of parameters)

25

50

75

IFEval

Family: meta-llama-3

train

test

Sloth basic

(d=3)

Sloth

(d=3)

FLOPs

(shared intercept)

PCA+FLOPs

(d=3)

10 0

10 1

10 2

0

50

10 0

10 1

10 2

50

75

MMLU

10 0

10 1

10 2

40

50

TruthfulQA

10 0

10 1

10 2

Size (billions of parameters)

60

80

ARC

10 0

10 1

10 2

Size (billions of parameters)

70

80

90

10 0

10 1

10 2

Size (billions of parameters)

70

80

Winogrande

Family: yi-1.5

train

test

Sloth basic

(d=3)

Sloth

(d=3)

FLOPs

(shared intercept)

PCA+FLOPs

(d=3)

10 0

10 1

10 2

0

20

40

MATH Lvl 5

10 0

10 1

10 2

30

40

GPQA

10 0

10 1

10 2

20

40

60

MMLU-PRO

10 0

10 1

10 2

Size (billions of parameters)

40

60

BBH

10 0

10 1

10 2

Size (billions of parameters)

40

45

50

MUSR

10 0

10 1

10 2

Size (billions of parameters)

20

40

IFEval

Family: yi-1.5

train

test

Sloth basic

(d=3)

Sloth

(d=3)

FLOPs

(shared intercept)

PCA+FLOPs

(d=3)

L Comparing against Ruan et al. [2024] in their observational scaling law setting

In this section, we compare Sloth with Ruan et al. [2024]'s observational scaling law; that is, we extract abstract skills using a set of benchmark scores and then use those skills to predict the performance of models of interest in a target downstream task. For this experiment, we use the same data and tasks explored in Section 4.4. For our method, we fit Sloth using benchmark data from all models, including performance data of LLaMa-3-70B models, and extract the skills of each model. For Ruan et al. [2024]'s method, we fit PCA on the benchmark data to extract the skills. For both methods, we set d = 3 and then fit a regression model with a logistic link to predict downstream performance from skills. Figures 37 and 38 present the prediction results for both methods and Figures 39 and 40 give the loading of both approaches. In both plots, out-sample prediction has a similar prediction error. At the same time, the in-sample fit is better for Sloth in the coding task and for Ruan et al. [2024]'s observational scaling law in the emotional intelligence task. Regarding the loading, it is possible to draw some similarities, e.g. , the presence of instruction following skill, but there is no one-to-one correspondence between skills.

3

2

1

0

1

2

3

4

5

T

HE

i

(

s

,

t

) +

c

0.0

0.2

0.4

0.6

0.8

1.0

HE Accuracy

Training Data

meta-llama-3-70b

meta-llama-3-70b-instruct

0

1

2

0.13

-0.39

1.52

HE

3

2

1

0

1

2

3

4

5

T

HE

(

PCA

) +

c

0.0

0.2

0.4

0.6

0.8

1.0

HE Accuracy

Training Data

meta-llama-3-70b

meta-llama-3-70b-instruct

0

1

2

1.05

0.79

0.44

15

10

5

0

5

10

15

T

EQ

(

i

(

s

,

t

)) +

c

0.0

0.2

0.4

0.6

0.8

1.0

Normalized EQ Score

Training Data

meta-llama-3-70b-instruct

0

1

2

-0.08

0.62

1.34

EQ

15

10

5

0

5

10

15

T

EQ

(

PCA

) +

c

0.0

0.2

0.4

0.6

0.8

1.0

Normalized EQ Score

Training Data

meta-llama-3-70b-instruct

0

1

2

1.94

-1.65

-1.19

EQ

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

0

1

2

0.03

-0.02

-0.21

-0.01

-0.00

0.02

-0.02

0.29

0.06

0.03

-0.02

0.57

-0.52

-0.63

0.06

0.11

0.07

0.15

0.08

0.01

0.44

0.56

0.57

0.05

3.54

3.56

2.24

1.73

1.80

1.69

0.85

0.75

0.68

0.52

0.65

0.33

MATH Lvl 5

GPQA

MMLU

MMLU-PRO

BBH

MUSR

TruthfulQA

ARC

Winogrande

IFEval

0

1

2

0.62

0.13

0.07

0.43

0.30

0.24

0.05

0.16

0.29

0.26

0.19

0.23

0.64

0.12

0.04

-0.09

0.00

-0.02

-0.02

-0.06

-0.37

-0.53

-0.27

-0.27

-0.05

0.04

-0.07

-0.11

-0.01

-0.04

-0.03

0.26

-0.16

-0.29

-0.20

0.87

F

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: abstract and introduction accurately reflect the paper's contributions.

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 to other settings.

It is fine to include aspirational goals as motivation as long as 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 include a section for limitations in the appendix.

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of 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 on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it 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 as grounds for rejection, a worse 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.

3. Theory assumptions and proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: we provide assumptions and proof.

Guidelines:

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.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a 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 or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. 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 explain the experimental setup in detail and share our code and data.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a 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 a 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 a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it 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 a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is 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 an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to 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, as described in supplemental material?

Answer: [Yes]

Justification: we make everything public.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/public/ guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be 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-source 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://nips.cc/public/ guides/CodeSubmissionPolicy ) for more details.

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 new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental setting/details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: we provide all details.

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 is 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 information about the statistical significance of the experiments?

Answer: [No]

Justification: most of our experiments do not need error bars to justify our conclusions. Moreover, for performance analysis, the data is not iid, so the usual error bar analysis is not valid here. An alternative would be having error bars across different families; in this direction, we provide results for individual LLM families in the appendix; they can be seen as a (more detailed) substitute for error bars for this application.

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, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments compute resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: we mention in the text that our model can be easily trained with a commercial laptop.

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 as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it 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://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: we made sure this holds

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 a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or 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: [NA]

Justification: there are no clear direct societal impacts.

Guidelines:

The answer NA means that there is no societal 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 or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of 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 any 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 to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for 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 as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: no clear risk of misuse of data.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-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 or restrictions to access the model or implementing safety filters.

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 to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: we made sure to credit third parties when needed.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets 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 are 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: they are well documented

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 submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You 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 screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: we used no crowdsourcing.

Guidelines:

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 to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional review board (IRB) approvals or equivalent for research with human subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: we had no study participants.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB 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 applicable), such as the institution conducting the review.

16. Declaration of LLM usage

Question: Does the paper describe the usage of LLMs if it is an important, original, or nonstandard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.

Answer: [NA]

Justification: we used LLMs mainly for rephrasing some paragraphs.

Guidelines:

The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non-standard components.

Please refer to our LLM policy ( https://neurips.cc/Conferences/2025/LLM ) for what should or should not be described.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe core contribution of this paper is the proposal of Skills Scaling Laws (SSLaws), or \"Sloth\". This new class of scaling laws aims to address the limitations of existing scaling laws, which often struggle to generalize across different LLM families due to variations in training configurations and data processing. Sloth posits that LLM performance on various benchmarks is driven by a set of low-dimensional, interpretable latent skills, such as reasoning, knowledge, and instruction following. Instead of directly modeling benchmark scores as a function of computational resources (like model size and training tokens), Sloth models how these underlying latent skills scale with compute.\n\nA key innovation of Sloth is its ability to leverage publicly available benchmark data across multiple LLM families. It assumes that while the efficiency of converting computational resources into skill levels may vary across families, the fundamental influence of resources on skills is similar. This allows Sloth to \"borrow strength\" across benchmarks and families, leading to more accurate and interpretable predictions. Furthermore, Sloth provides theoretical results on parameter identification and demonstrates practical applications, including predicting performance in complex downstream tasks, understanding behavior with scaled test-time compute, and deriving optimal-scaling rules for skills given a compute budget.\n\nSTRENGTHS AND WEAKNESSES:\nStrength: \nThis paper has several clear strengths. \n1. Address important limitations of previous work: I appreciate the authors' taking Section 2 to compare against previous studies and better position the paper's contributions. Previous work either ignores the family-dependent feature of the scaling law or has the model first then predict the performance on non-evaluated benchmarks. This paper addresses these limitations by encoding the correlation structure between benchmarks. \n\n2. Practical experiments and setups: The Authors evaluated their methods in a practical setting where only one or two models with the smallest sizes are trained, and predict the performance of the large models. \n\n3. Improved predictive accuracy and generalizability: Experimental results consistently show that Sloth performs competitively, often achieving similar or lower mean absolute errors than baselines, even for recent and diverse LLM families like LLaMa 3, Qwen 2, and Yi 1.5. \n\nWeakness: \n\nI found no critical weaknesses.\n\nQUESTIONS:\nQ1: why is theta considered to be latent skills or `reasoning'? What's your clue and what's the justification?\nQ2: If I understand correctly, your alpha is family-dependent variable. How do you model the family with only the smallest model given, as described in L223-236? \n\nQ3: l252, Which figure shows the results of the two observed models? Your link directs to a bunch of figures.\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "CLARITY": 3, "IMPACT": 4, "ORIGINALITY": 3, "DATE": "2025-07-01"}

comments: SUMMARY:
This paper proposes to include model family to estimate scaling laws across data and models.

STRENGTHS AND WEAKNESSES:
The paper is well written, and provides a through analysis across benchmarks. 
The authors claim that family specific intercepts are not always needed (Figure 3), and add some worst case analysis to their results. However, these conclusions should be highlighted in the main test
The method sees little benefit from adding more samples within a model family as long as there is enough data available for a wide variety of datasets; however, outside of the model family the model can under/over estimate performance. It is unclear when it is biased towards either failure model.

QUESTIONS:
- How much data/benchmarks are needed to make predictions for a new model family? Is this exacerbated given the heavy tailed nature of the data? How does this relate to the diversity of benchmarks? 
- How much does the predictive performance change as you add more samples? Given that 
- In Figure 6, sloth overestimates the performance of pythia, can you elaborate for which scenarios the proposed model  over vs under estimates the performance?

LIMITATIONS:
yes
TITLE: Official Review
CLARITY: 3
IMPACT: 2
ORIGINALITY: 1
DATE: 2025-07-03

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nDue to the inherent differences across model families, existing scaling laws often fail to generalize universally across LLMs. Constructing separate scaling laws for each model family, however, incurs substantial computational cost. To address this challenge, this paper proposes Skills Scaling Laws (SSLaws, Sloth), a method that leverages publicly available benchmark data and assumes LLM performance is driven by a set of low-dimensional latent skills—such as reasoning and instruction following. By exploiting the correlation structure across benchmarks, Sloth enables more accurate and interpretable performance prediction, while alleviating the need to train multiple models per family. Empirical results demonstrate that Sloth accurately predicts LLM performance and provides valuable insights into downstream scaling behavior, test-time compute efficiency, and compute-optimal skill development.\n\nSTRENGTHS AND WEAKNESSES:\nStrengths:\n1. By leveraging publicly available benchmark data and the concept of latent skills, this work proposes a resource-efficient approach to model performance prediction. In addition to reducing the need for training multiple models, the method offers valuable insights into the interpretability of model capabilities.\n\nWeaknesses:\n1. The main method proposed in this paper is quite similar to that of Ruan et al., but the fundamental differences between the two are not clearly explained in the related work section or in the subsequent content.\n\n\n[1] Yangjun Ruan, Chris J. Maddison, and Tatsunori Hashimoto. Observational Scaling Laws and the Predictability of Language Model Performance, July 2024.\n\nQUESTIONS:\n1. Are the identified latent skills strongly correlated with the choice of benchmark datasets? How does the number of these skills influence the model’s predictive performance?\n2. If certain benchmarks are potentially contaminated during model training, to what extent can their evaluation results be considered trustworthy?\n3. Beyond predicting model performance on benchmarks, can this scaling law offer guidance for model training or the adjustment of specific capabilities? Given that benchmark datasets may not always faithfully reflect the full spectrum of a model’s abilities, it would be valuable to understand whether the proposed method can inform capability refinement or training strategies.\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 3, "CLARITY": 2, "IMPACT": 3, "ORIGINALITY": 2, "DATE": "2025-07-03"}

comments: SUMMARY:
This paper proposes Sloth, a new class of scaling laws that predicts large language model (LLM) performance across benchmarks and model families. The core idea is to represent LLM capabilities using a small set of interpretable latent skills (like reasoning and knowledge), which scale with compute. Sloth leverages leaderboard data and allows for family-specific efficiency without requiring multiple models per family. It supports flexible, optionally learned activation functions to improve prediction accuracy. The method is validated across 12 benchmarks and used to forecast downstream task performance for unseen, larger models.

STRENGTHS AND WEAKNESSES:
Strengths:

1. The paper is very well written, with clear structure and logical flow throughout.

2. The authors conduct thorough ablation studies, which help isolate the contribution of each component in the proposed method.

Weaknesses:

I did not find major weaknesses in this work. 

1. I’m particularly interested in the design choices behind the proposed scaling law formulation. It would be helpful if the authors could share more motivations and potentially failed alternatives. Why is each skill slope shared across families in Equation (3.2)?

2. I’m not fully convinced by the interpretation of benchmark-skill associations in Section 4.3. In particular, I believe MMLU might be more appropriately categorized under knowledge-based skills rather than reasoning.

QUESTIONS:
Please see Weakness part

LIMITATIONS:
Please see Weakness part
TITLE: Official Review
CLARITY: 3
IMPACT: 3
ORIGINALITY: 3
DATE: 2025-07-05