MERGE$^3$: Efficient Evolutionary Merging on Consumer-grade GPUs
Authors: Tommaso Mencattini
Robert Adrian Minut
Donato Crisostomi
Andrea Santilli
Emanuele Rodolà
Venue: ICML 2025 poster (2025)
Keywords: Model Merging
Evolutionary Algorithms
Efficient Methods for Machine Learning
Language Models
LLMs
Multilingual Models
Primary area: deep_learning->algorithms
TL;DR: We enable efficient evolutionary model merging on consumer GPUs with IRT-based estimation.

Abstract: Evolutionary model merging enables the creation of high-performing multi-task models but remains computationally prohibitive for consumer hardware. We introduce MERGE$^3$, an efficient framework that makes evolutionary merging of Large Language Models (LLMs) feasible on a single GPU by reducing fitness computation costs 50× while retaining a large fraction of the original performance. MERGE$^3$ achieves this by **E**xtracting a reduced dataset for evaluation, **E**stimating model abilities using Item Response Theory (IRT), and **E**volving optimal merges via IRT-based performance estimators. Our method enables state-of-the-art multilingual and cross-lingual merging, transferring knowledge across languages with significantly lower computational overhead. We provide theoretical guarantees and an open-source library, democratizing high-quality model merging.

MERGE
Efficient Evolutionary Merging on Consumer-grade GPUs
Tommaso Mencattini !
Adrian Robert Minut 2
Donato Crisostomi 2 Andrea Santilli Emanuele Rodolà 2
Abstract
0.5
Evolutionary model merging enables the creation of high-perforning multi-task models but re- mains computationally prohibitive for consumer hardware. We introduce MERGE', an effi- cient framework that makes evolutionary merg- ing of Large Language Models (LLMs) feasible on a single GPU by reducing fitness computa- tion costs 50x while retaining a large fraction of the original performance. MERGE achieves this by Extracting a reduced dataset for evaluation, Estimating model abilities using Item Response Theory (IRT), and Evolving optimal merges via IRT-based performance estimators. Our method enables state-of-the-an multilingual and cross- lingual merging, transferring knowledge across languages with significantly lower computational overhead. We provide theoretical guarantees and an open-source library, democratizing high- quality model merging.
@MLRGC-100
50x reduct Ton
BroLL
6.6
Avcuney
Abel-7B
0.2
2th NVIDIA
0.1
Tack Art arithretic
2 TELOPs
x10
Figure 1. Accuracy on Japanese GSMBK over fitness evaluation FLOPs. MERGE. is competitive with model evolved the full dataset by only using a consumer-grade GPU and 2% of the data (point size reflects data amount).
This approach has significantly broadened access to the field, with ML practitioners producing competitive models out of existing ones on standard consumer GPUs' (Ilharco et al., 2022). However, although computationally inexpen- sive, most of the existing approaches are quite rudimen- tary, require ad-hoc choices, and are usually based on un- grounded trial-and-error strategies for selecting the merge coefficients, which ultimately limits their downstream per- formance (Yadav et al., 2023; Yu et al., 2024). On the other hand, recent work has shown that evolutionary merging can produce models of unprecedented quality by automating the hyperparameter search for merging coefficients (Ak- iba et al., 2025). While this technique can incorporate any standard merging method, such models are absent from public leaderboards likely due mismatch between the high computational demands of evolutionary merging and single-GPU setups typical of merging practitioners. Indeed this computational cost is significantly high: computing the fitness function requires generating and evaluating answers for each dataset element, for each candidate in every evo- lutionary step. As shown Figure 1, the fitness computa- tion alone in the 1,000-trial evolutionary merge from Ak- iba et al. (2025) requires approximately 4 x 106 TFLOPs, with the full algorithm demanding largely over month of
github. http/////mmmmmmmtttt/eeeeeeeeeee
1. Introduction
Model merging has become a powerful and accessible ap- proach for developing new ttae-off-the-an the-art models without the need for suuter-gradee computing typically required for large model training (Yang et al., 2024a). Its key advantage lies in performing the merging process post-hoe directly in the parameters of endpoint models-thar is, pre-existing models (either base or fine-tuned) that serve as the com- ponents of the merging training and significantly reducing the demand for expen- sive computational resources.
the need for
"Equal contribution 'School of Computer and Communication Science, Ecole Polytechnique Fédérale de Lausanne, Lausanne, Switzerland Department of Computer Science, Sapienza Univer- sity of Rome, Rome, Italy. Correspondence to: Tommaso Men- cattini coommaso.mencatiin @etpaaiiiiiittl.........
Proceedings of the 1nnd International Conference Machine Learning, Vancouver, Canada. PMLR 267, 2025. Copyright 2025 by the author(s).
At the time of writing, around 30% of models the Hugging Face Open LLM leaderboard are merged models.

---

Efficient Evolutionary Merging on Consumer-grade GPUs
continuous computation if run on single NVIDIA 4090 (SC.3.3) with 24 GB of VRAM. Requiring repeated and costly runs of large language models, the fitness evaluation is the primary bottleneck. This makes evolutionary merg- ing out of reach on consumer hardware, potentially exclud- ing the very users it was meant to empower.
Data Bt
Endpoints Models
Sampling
[e]
Exo Merge
X Eval
@ X Eval
In this paper, we address this challenge by introducing MERGE., an evolutionary merging framework that runs on single consumer GPU with competitive results (see fig. 1). Unlike the competing approach, MERGES operates with just 0.077 x 10t TFLOPs, namely a 50-fold reduc- tion. This drastic decrease in computational cost makes it feasible on consumer hardware, freeing up FLOPs for fur- ther optimization or additional tasks.
Performnce Extimattrr
Abllly
Alslity
y
7%
Y,
Reduced Set
Abiliy Parameters
Merged Model
Extract & Estimate
Evolve
Our approach starts by Extracting reduced subset of the fitness evaluation dataset, significantly alleviating the com- putational bottleneck of fitness computation (fig. 2). How- ever, this reduction risks losing accuracy if the subset lacks diversity. To address this, we apply Item Response The- ory (IRT) (Lord et al., 1968)-a a well-cstablished statisti- cal framework to bridge the gap between reduced-dataset evaluations and full-dataset performance. Specifically, we first Estimate the latent abilities of the endpoint models using IRT, ensuring the merged models accurately reflect their components' strengths. Then, we Evolve the endpoint models with IRT-based performance estimators designed for model merging, assuming the merged model's ability a combination of those of the endpoint models. This ap- proach significantly improves the efficiency and accuracy of fitness estimation, integrating merging-specifer insights into performance estimation theory while maintaining high accuracy with reduced datasets.
Figure 2. MERGE for math + Japanese merging (GSM8K). The method Extracts a reduced evolutionary dataset, Estimates ability parameters (?) via Item Response Theory (IRT) based on their response correctness, and Evolves the endpoint models through iterative merging. Leveraging an IRT-based performance estimator, it approximates full-datase fitness with reduced data, cutting fitness estimation costs while preserving full-dataset accu- racy - making evolutionary merging feasible on consumer GPUs.
across languages and synthesizing state-of-the-art multilingual models without standard training.
We advance the theoretical foundations of perfor- mance estimation in model merging and provide for- mal guarantees for our proposed estimators.
We release a modular library for evolutionary merging on consumer GPUs, alongside suite of state-of the- art models for several low-resource languages.
Experimental results show that MERGE3 effectively trans- fers mathematical skills by merging a strong math model with three language-specific models, achieving 10-20% higher accuracy than standard merging baselines in each language. Building this, we evolve single multi- lingual model by merging Italian, English, German, and Dutch models, outperforming individually fine-tuned mod- els by up to 19% on ARC (Clark et al., 2018), a widely used benchmark for reasoning. Furthermore, MERGE3 achieves competitive accuracy on Japanese GSM8K (Cobbe et al., 2021), matching models evolved on full datasets while maintaining high efficiency, demonstrating that our evolutionary strategy preserves performance while drasti- cally reducing computational costs.
2. Related Work
Model Merging has emerged as an efficient alternative to ensembling by integrating existing models without any additional training. One set of methods identifies neuron permutations that align the models into shared optimiza- tion basin, allowing them to be merged through straight- forward averaging (Ainsworth et al., 2022; Jordan et al., 2023; Stoica et al.; Peña et al., 2023; Crisostomi et al., 2025). Closer to our work, multi-task model merging fo- cuses on the case where single pre-trained model is fine- tuned for different tasks (Ilhareo et al., 2022; Yadav al., 2023; Yu et al., 2024; Matena & Raffel: Wortsman al., 2022; Davari & Belilovsky, 2025; Wang et al., 2024; Zhou et al., 2024; Gargiulo et al., 2025). In this direction, sev- eral works address task interference by pruning or selec- tively combining parameters- e.g., et al., 2023), Model Breadcrumbs (Davari & Belilovsky, 2025), and DARE Merging (Yu et al., 2024) or by opti-
To summarize, our contributions are fourfold:
We introduce a novel, efficient evolutionary model merging framework leveraging Item Response The- ory, making merging feasible on consumer hardware.
( (Yaday
We demonstrate its effectiveness in transferring skills
2

---

Efficient Evolutionary Merging on Consumer-grade GPUs
mizing merge coefficients (Yang al.), introducing task- specific modules (Yang et al., 2024b), and disentangling weights (Ortiz-Jimenez al., 2024).
uation. It achieves this by shrinking the fitness evalu- ation dataset and using IRT--based performance estima- tors to maintain full-dataset accuracy from subset eval- uations. Figure 2 shows an overview of our method, while we present below the pseudo-code for the end-to-end MERGE algorithm.
Evolutionary Algorithms. Evolutionary Algorithms are black-box optimization algorithms operating on a pop- ulation of potential solutions by evolving them through generations with operators such as selection, mutation, recombination, and crossover (Bäck & Schwefel, 1993; Pétrowski & Ben-Hamida, 2017; Dasgupta & Michalewicz, 1997). Recent applications include neural architecture search (Real et al., 2019) and hyperparameter tuning (Vin- cent & Jidesh, 2023), where evolutionary methods effi-
Algorithm 1 The full MERGE* algorithm.
Require: Dataset D, models {M1. M2..... M, iterations T Ensure: Pareto-optimal merged models
Đ < RANDOMSAMPLE ( k) Sample & items from D
2: (mi....;7m} < ASTTMAYTEABBIIIIIISS (M...... Mn), D)
3: P Generatelnniiallouulaaooon (M,.... M..)
4: for 1 4- 1 to T do
ciently navigate large design spaces without manual in- tervention. The fitness function is crucial, as it evaluates
5:
for all M E P
6:
À + FITLAMBDA(M, tn.... Yah h D)
the quality of each solution, guiding the selection process
7: preds <- GETPREDICTIONS(M M, D, X)
by favoring higher-scoring (fitter) solutions for reproduc-
8:
coTr + GETCORRFCTNESSS prredss preds, D)
tion (Eiben & Smith, 2015). Closest to our work, Akiba et al. (2025) propose to apply evolutionary algorithms to optimize model merging recipes, eliminating the need for trial-and-error in combining parameters. In this context, the most obvious candidate for fitness function is sim- ply the performance of the resulting model over held-out
9:
F(M) <- ESTIMATEFFINESS(Coor 2) end for
10:
11:
P 4- SELECTPARENTS(P.T
# &Select based on fitness
12:
P 4- APPLYMUTATION
13:
P+ APPLYCROSSOVER( P)
Generate offspring
14: end for
15: return PARETOFRONT(P)
validation set.
Item Response Theory. Item Response Theory (IRT)
3.1. Extract & Estimate
(Cai et al., 2016; Van der Linden, 2018; Brzeziniska, 2020; Lord et al., 1968) is a paradigm to design, analyze, and score responses to tests such as SAT or GRE (An & Yung, 2014; Kingston & Dorans, 1982; Petersen et al., 1982). Based on the relationship between individuals' per- formances on a test item and the test takers' levels of per- formance on the corresponding required ability, IRT has re- cently spread from psychometries to natural language pro- cessing. In this direction, Lalor et al. (2016) leverage IRT's latent dimensions to evaluate language models, while Va- nia et al. (2021) use to analyze benchmark saturation in NLP evaluations. More relevant to our work, Zhuang et al. (2023) and Polo et al. (2024) employ IRT-driven adaptive testing to alleviate the computational burden of large-scale evaluations for large language models (LLMs). Although their focus is LLM evaluation, which shares similarities with the efficient evaluation of fitness functions in model merging, our work builds on these approaches to design IRT-based estimators specifically tailored for model merg- ing. Unlike prior applications of IRT, which are limited to LLM evaluations, our approach adapts the framework to address the unique challenges of evolutionary model merg- ing, enabling efficient and accurate fitness estimation.
Evaluating the fitness function involves generating and as- sessing answers for each data sample, repeated across all models in the population at every evolutionary step. Given the computational demands of evolutionary algorithms and LLMs, this process is highly intensive. To mitigate this, we reduce the dataset to a smaller subset D C D with D & |D] After exploring various subsampling strate- gies, we found uniform random sampling as effective as more complex methods (see appendix C.1) and adopted it for simplicity. Since dataset reduction is not our main fo- cus, we leave further optimizations for future work.
Reducing the dataset speeds up evaluation but does not guarantee identical results particularly when the subset is significantly smaller, in our case. To bridge this gap, we build an IRT-based estimator that adjusts for this dis- crepancy, effectively estimating performance to reflect full- dataset results (Lord et al., 1968; Polo et al., 2024).
IRT model. We first define an estimator to assess each endpoint model's inherent abilities, derived from the latents of a Bayesian network. This ensures that merging preserves individual model strengths. In the Evolve step ($3.2), the estimated latent abilities are fed to a performance estimator to compute the final fitness.
3. MERGE3 3
Our method MERGE² speeds up evolutionary model merg- ing by reducing the computational cost of fitness eval-
To estimate LLM abilities, we build on Polo et al. (2024), who applied IRT to evaluate L.M performance; however,
3

---

Efficient Evolutionary Merging on Consumer-grade GPUs
while they used IRT for benchmarking, we extend it to es- timate inherent abilities relevant for model merging, and explicitly use them to guide merging in the Evolve step.
stead of evaluating the full dataset, the estimator predicts performance using only the endpoint models' abilities and the reduced dataset from previous steps, significantly ac- celerating the process.
In IRT. latent variables (γ) represent a model's underly- ing abilities, while manifest variables (Y) indicate response correctness. The framework models the probability of a correct response based on model abilities and item charac- teristies (e.g.. difficulty)).
We introduce two novel performance estimators for merg- ing: merged performance Item Response Theory estimator (MP-IRT) and generalized merged performance Item Re- sponse Theory estimator (GMP-IRT). Since model merging linearly combines weights, we assume that the latent abili- ties of the merged model (e.g., problem-solving linguis- tic capabilities) are also a linear combination of the end- points' abilities. This makes our approach far more effi- cient, estimating only the interpolation coefficients (A,) in- stead of recomputing the full ability vector y of the merged model from scratch (as done in P-IRT and GP-IRT (Polo et al., 2024)).
IRT defines this probability as:
P(Y.m Ymm Cis, Bi) = 1 + exp(- Tm - B₂)
Here, T'm E _d represents model m's latent abilities, ay E Rd defines the ability dimensions needed to answer exam- ple i, and 33 denotes its difficulty. A model is more likely to answer correctly when its abilities (7m) align with the example's required traits (ax)) and less likely when the dif-
Assumption 1 (Linear Combination of Latent Abilities). Lei {mo,, m.,..... ,ma) be endpoint models with latent ability vectors "hS If a new model m is formed as a lin- ear combination of their parameters, its ability vector 7 can be expressed as:
ficulty (8)) is higher. Yim a binary variable indicating whether model m correctly predicts example i (1 if correct, O otherwise).
Crucially, this approach estimates model's likelihood of answering correctly without directly analyzing the exam- ple's content, relying solely on the estimated IRT parame- ters (Tm ag 3.).
Pi = Enys = Ii...,,
(2)
j=1
where A = (AI, An) are the interpolation coefficients.
Fitting. We use variational inference to efficiently es- timate both example-specific (0), and model-specific (7m) parameters within a hierarchical Bayesian model (Lalor & Rodriguez, 2023), initialized as detailed in ap- pendix B.1. Following Polo et al. (2024), we estimate and 33 using correctness data (Yim) from publicly available model evaluations, namely the Open LLM leaderboard. To estimate 7m. each endpoint model generates answers for the full evaluation dataset, which are then used to assess correctness (Y2) (see Figure 2). This procedure is repeated for each model m, producing the corresponding "/m. (71 and 722 in the Figure).
This assumption allows us to compute the multidimen- sional IRT model (Eq. 1) for model merging as a linear combination of the individual models' abilities:
Pin IP km 1 A17 + A272, 04 (.)
(3)
1 expeexepppp (Am )272) + B.)
Since the endpoint models' latent abilities Y were pre- estimated over the full dataset D in the Estimate step, we only need the subset D estimate the interpolation coeffi- cients X, via MLE.
To summarize, unlike previous work, where IRT latent abil- ities remain hidden variables, we explicitly derive YYo as an ability estimator to quantify each model's strengths. Addi- tionally, rather than estimating Tm from subset, we com- pute it using the full evaluation dataset, providing more comprehensive measure of model ability, which we now leverage to enhance the merging process.
Performance Estimators. To estimate the accuracy of the merged model m using only the reduced dataset D and Pin. we define the merged performance-IR" (MP-IRT) es- timator as:
Amp-IRT 7 |D
ΣYan IED
Yun +
1-
Σ pim (4) iEDVD
|DAD
3.2. Evolve: Performance Estimator
where f be noisier. In practice, we are considering the ob- served correctness for the data points we have access to, while Pam predictions are used for the rest, en- abling accurate performance estimation across all exam- ples despite evaluating only subset, where Pim =
D downweights smaller subsets that may
The performance estimator, key part of the Evolve step, efficiently approximates the fitness function, which mea- sures the merged model's accuracy. Since fitness evalua- tion runs repeatedly during evolution (once per model per iteration), reducing its computational cost is crucial. In-
4

---

Efficient Evolutionary Merging on Consumer-grade GPUs
ARC
GSM8K
TruthfulQA
Average
0.10
0.12
0.10
0.10
Absolute Eiror
0.10
0.08
0.08
0.08
0.06
0.06
0.06
0.06
0.01
0.04
0.04
0.04
10 20 30
50
100
10
20 30
50
100
10 20
100
20
30
50
100
Number of Samples
Number of Samples
Number of Samples
Number of Samples
p-IRT
gP-IRT
f
mp-IRT (ours)
gmp-IRT (ours)
Random
Figure 3. Performunce Estimators: Absolute enror of various estimators function of sample size (lower is better). Our MP-IRT and GMP-IRT estimators consistently achieve lower error across various sample sizes and datasets. Additional results available in Figure 13,
PY 81 + S2n2 dis 3:) is the distribution de- fined by plugging into (3) the parameter found via MLE.
ARC
BAllaBung
ARC
BallaSvag
Although designed for model merging, 2m inherits certain limitations of p-IRT (Polo al., 2024), such as non-uniform weighting and imperfect IRT fits. To mitigate these, we define generalized estimator that interpolates between mRp and the observed correctness on D: Ti
Vinagranie-
frotatu1yA
Wisagraudee
Testhrulge
( IRT
(.eeoel IRC (ous)
GRT m
Σ w. Yum + (1 c) c) Smp-IRT IED
(5)
m
Figure 4. Ability Estimator: Cosine similarity between estimated and true abilities for different tasks (higher is hetter). Our esti- mated abilities y (mppamp)--ne better approximate true abilities.
where e is heuristic scalar and w, are uniform per-sample weights. We discuss in appendix C.2.3 the optimal choice for Although model merging can sometimes degrade performance due to weight interference-sugene suggesting non- linear ability interactions- our assumption is empirically supported as we are interested only in evolved models that show a positive performance gain. As validated our ex- periments (54.1), 1), our custom estimators, designed around this assumption, outperform standard IRT estimators.
where > denotes Pareto-dominance. A model m Pareto- dominates m if:
FF E FD: F(m; D) < F(m'; and
3F FD: F(m; D) F(m';
This means is strictly better in at least one metric and no worse in all others. Models on the Pareto front are thus not dominated by any other model.
3.3. Evolve:
Evolutionary Search
The final step of our algorithm frames model merging as multi-objective optimization problem. Each merging ob- jective F (m, D,) represents the performance of the merged model m on task i. In practice, we select a multi-objective evolutionary algorithm (e.g.. NSGA-II (Deb et al., 2002)) and a merging strategy (e.g., TIES (Yadav et al., 2023)), aiming to optimize the corresponding Pareto front, for- mally defined as:
In our setting, to reduce computational costs, we approxi- mate optimization using Fp instead of Fp. where D D is obtained by the extraction step. Performance 1 is then estimated using the performance estimator.
4. Experiments
In this section, we evaluate MERGE3 demonstrating its effectiveness evolutionary model merging on consumer-
PF, (0) = ={0, E e:: 30, e s.t. 02 > 0.}
5

---

Efficient Evolutionary Merging on Consumer-grade GPUs
0.4
0.37
0.11
0.4
0.39
0.4
Accurcy
0-3
0.22
Accuracy
0.3
0.21
Avcuray
0.20
0.16
0.2-
0.19
0.20
0.2
0.14
0:06
1108
0.1
0.11
0.1
0.09
0.02
0.02
0.03
0.0
0.0-
0.04
TIES-DARE
T4
SLERP
Ro
MetaMoth
MERGE
SLERP
Alel
DE
THES DARE
T4
Artthmo
MERGET
TIES-DARE
SLERF
M
MetaMath
MERGLE
(a) To Romanian,
(h) To German.
(c) To Dutch.
Figure 5. Cross-lingual skill transfer: merging math models (dark blue) with language-specific models (red) effectively transfers math- ematical skills across languages (green- our method) compared to baselines (white), Accuracy on GSMSK for each target language.
Ability Estimators. To validate our ability estimators we compare their inferred latent ability vectors the refer- ence "ground-truth" vectors I. Specifically, we measure the cosine similarity and the Euclidean distance from the ground-truth I' both for (mpp.gpppp estimated with our merged-pprrorraan
3.5
0-15
1.4
0:31
0.21
0.2
IRT approaches, and andd (P-8P)) es- timated with the P-IRT and GP-IRT estimators (Polo et al., 2024). Here, I I'm is computed by fitting the IRT model (as in section 3.1) to each merged model m using its entire set of responses on the full dataset D. Incorporating all avail- able data, I'm serves our best proxy for the model's 's true ability. Conversely, both Ym are estimated using only a smaller subset D C of size n. Figure 4 shows the results of this comparison for and = 20, while the results for 15, 30, 50, 100 are reported in Appendix C.2 along with the same experiment over different languages. Across all five benchmark tasks [mp.gmp)- consistently our proposed ability estimator 7/ yields ability vectors with higher cosine similarity to I' than 7m (p. This trend evident across both subset sizes, highlighting the robustness of our approach even with lim- ited data. The superior performance of yym [mp.gmp)- pirically validates Assumption 1, confirming that an IRT- based ability estimator designed around this assumption provides more accurate ability estimates than a general- purpose alternative.
9.2
0.01
0.2
0aa5 70
Task Anilants
Endd 1P:10
(p-Ep)- IRT (mp.gmp) IRT and Ti
Figure 6. Accuracy of merged models for Japanese GSMBK,
10
grade GPUs We first validate the proposed ability and per- formance estimators, assessing their accuracy in approxi- mating full-dataset evaluations. Next, we examine cross- lingual transfer, where MERGE3 enables efficient merging of multilingual models, improving mathematical reason- ing across languages. Thereafter, we evaluate its ability to synthesize multilingual models, surpassing individual fine- tuned baselines while remaining computationally efficient. Finally, we analyze the performance of MERGE3 on dif- ferent GPUs All the merging experiments were performed with our custom-made library Mergenetic (see Appendix A) on a RTX 4090 GPU featuring 24 GB of VRAM, while employing batch size of 8, 4-bit quantization, and models comprising x 7 billion parameters (see Appendix B).
em-
Performance Estimators. To assess the accuracy of our proposed performance estimators, we measure their abso- lute estimation error across different sample sizes. Specifi- cally, we evaluate the performance estimates of six merged models using random sampling, P-IRT, GP-IRT (Polo et al., 2024), MP-IRT, and GMP-IRT across various sub- set sizes. The resulting absolute errors shown in Figure 3 are reported for ARC, GSMSK, Truthfulq2 QA, and an ag- gregate average across all five benchmarks.
4.1. Validating Estimators
In this section, we empirically validate our merged- performance estimators by comparing them against standard P-IRT and GP-IRT estimators (Polo et al., 2024) across five benchmark datasets: GSMBK (Cobbe et al., 2021), Winogrande (Sakaguchi et al., 2021), frAt (Lin et al., 2022), Hellaswag (Zellers et al., 2019), and ARC (Clark et al., 2018). Due to space limitations, additional results are provided in Appendix C.
As shown in the figure, our proposed estimators, MP- IRT and GMP- IRT, consistently achieve lower absolute er- ror compared to GP-IRT and P- P-IRT. While all IRT-based
6

---

Efficient Evolutionary Merging on Consumer-grade GPUs
methods outperform random sampling, the incorporation of perfedeperformance IRT significantly enhances estima- tion accuracy. Notably, both MP-IRT and GMP-IRT main- tain low empirical eπror and reduced variance even when operating with very small subsets ( (D) R 1.5% of the full dataset). This highlights the robustness of our approach in low-data regimes.
0.32
0.34
0.3-
Accuary
0.23
0.2
0.1
0.02
0.0
Mistral- 7B-v01 Mistral-T-xx0.11
Self-Maaee
17
MERGE
Since lower empirical error often correlates with reduced expected error (as formalized in Section 5), we adopt MP- IRT and GMP-IRT our primary estimators for evolving merged language models in subsequent experiments.
Figure 7. Accuracy of the base model (Mistral-7B), the Italian Endpoint (TT), Self-Merge and MERGE" models on the Italian- translated version of GSMSK.
4.2. Cross-Lingual Transfer of Mathematical Skills
To assess the transfer of mathematical reasoning from English to other languages, we merge an English math- specialized model with a ai (Jiang et al., 2023) fine-tuned on each target language, then evaluate on the corresponding GSM8K translations (Cobbe et al., 2021). Appendix B.2 provides details on the specific models used label
4.3. Ablation Study: Self-Merging
In this section, we present an ablation study to test whether the observed improvements in the merged models arise from genuine cross-lingual knowledge transfer or merely from fitting to the prompt template. To structure this anal- ysis, we formalize our inquiry through two hypotheses:
for merging. Following Akiba et al. (2025), an answer correct only if it is both accurate and writ- ten in the target language. We benchmark our approach against three commonly used merging baselines Task Arithmetic ic (Ilharco et al., 2022), TIES (Yadav et al., 2023) and DARE (Yu et al., 2024). Following standard prac- tice in the merging community, we apply either TIES and DARE jointly or SLERP (Shoemake, 1985).
Null Hypothesis (Ho). The improvements seen in the merged models are due to the model fitting itself on the prompt template, rather than any cross-lingual knowledge exchange.
Alternative Hypothesis (H The improvements arise from actual cross-lingual knowledge transfer and are not merely the result of fitting the prompt template.
As shown in fig. 5, merging language-specifit fine-tuning with a math-sppecalizze model consistently surpasses both endpoint models by 10-20% in accuracy on the trans- lated GSM8K. In contrast, standard basclines often yield sub-optimal merges, performing worse than the endpoints themselves. This highlights the importance of optimized merging coefficients and motivates our evolutionary frame- work.
To evaluate these hypotheses, we propose self-merging procedure. Concretely, we take the linguistic model and merge it with itself using the standard MERGE3 method- ology outlined in algorithm 1. Under Ho. if the improve- ments are solely due to the prompt template, merging the model with itself should lead to performance gains (i.e., the merged model would still "fit" the template). Conversely, under Hi if cross-lingual knowledge transfer is responsi- ble for the enhanced performance, self- merging should not yield improvements. In fact, additional noise could even degrade performance relative to the baseline.
Next, we evaluate our method for transferring math skills from English to Japanese and compare it to EvoMerge (Akiba et al., 2025), which serves as an upper bound by computing fitness on the full dataset. As illustrated in figure 6, our approach confirms the significant gains seen for the other languages, greatly surpassing both the per- formance of the endpoint models and that of the merging baselines. While the accuracy is lower than that of the model obtained by computing the fitness on the full dataset as done by Akiba et al. (2025), figure shows that our ap- proximation yields a method that is 50x more efficient, ef- fectively making evolutionary merging feasible on a single consumer GPU.
We conducted this self-merging experiment on the Ital- ian model using the GSM8K dataset. The results, shown in fig. 7, reveal that performance actually decreases when the model is merged with itself. This observation strongly supports the alternative hypothesis (Hf)): the performance gains in cross-lingual merges indeed stem from gen- uine knowledge transfer, rather than mere adaptation to a prompt template.
4.4. Evolving a Multilingual model
We next combine individually fine-tuned models for {IT, EN, DE, NL. into a single multilingual model. Ap-
7

---

Efficient Evolutionary Merging on Consumer-grade GPUs
of the accuracy on the true optimum dataset. The proofs for all the theorems and propositions presented below outlined in appendix D.
Table 1. Evolving multilingual model. For each language, report the accuracy on the corresponding translated ARC of both the -ppeuage--pecific model and evolved multilingual model.
Accuracy (1)
5.1. Part I: c-Stable Estimators and c-Optimality Preservation
Model
Italian
English
German
Dutch
Finetuned
0.61
0.75
0.61
0.50
MERGE3
0.69
(18%)
0.79
(14%)
0.72
(11)))
0.69
(119%)
We first consider performance metric F(0; D) for 0 e θ C R", where D is a dataset. If we choose smaller sub- set D C D to approximate this metric, denoted F(;; D), we wish to control the loss in optimality incurred by replac- ing F(0; D) with F(0; D).
pendix B.2 provides details on the specific models used for each language. As shown in table 1, the resulting merged model surpasses each language-specific variant by up to 19% in accuracy on the ARC-Challenge dataset (Clark et al., 2018). Even more notably, it outperforms all its constituent endpoints, demonstrating a clear positive trans- fer of knowledge across languages. Beyond the clear ac- curacy boosts in each language, few key insights stand out. First, the largest improvement occurs for Dutch (from 50% to 69%), suggesting that merging particularly ben- efits languages where the baseline performance is lower. Second, even English, which starts from the highest base- line, still gains by 4%, indicating that positive transfer is not limited to low-resource or weaker endpoints. Finally, the fact that the merged model outperforms all individual fine-tunings (rather than landing between them) points to genuine cross-lingual synergy, wherein knowledge from each language-specific model collectively strengthens the multilingual result. These conclusions are further strength- ened by the ablation study in section 4.3, where we assess whether the observed improvements in the merged models arise from genuine cross-lingual knowledge transfer.
Definition 1 (e-Stability.). Given two datasets D and D, we say F(; is e-stable with respect F(:; D) if, for all 0 E O,
D) - F(0; D) S
Under this condition, minimizing F(:: D) yiclds an objec- tive value within of minimizing F(;; D). Formally:
Theorem 2 (e-Optimality Preservation). Let D be dataset, let D C D be a subset, and let F(;; D) be e-stable with respect to F(:; D), with a fixed > Define
0r argmin F(0; D) and Ô argmin F(0; D) BEB
BEE
Then
F(O*: D) - F(O: Se
Thus, e-stability ensures that any global minimizer on D achieves an objective value on D no worse than e from the true global optimum. Nevertheless, uniformly bounding F(0; D) F(;; D) for all may too strong practice. For this reason, we introduce:
5. Theoretical Analysis
Definition 3 (e-Stability in expectation). Given two datasets D and D, we say F(: is e-stable in expecta- tion with respect to F(; if
In this section, we provide theoretical guarantees for our performance estimator, demonstrating that its estimated accuracy is a reliable approximation of full-dataset accu- racy. We provide formal guarantees for its performance, analyze its stability under dataset reduction, and explain why it remains robust proxy for the true fitness of the merged models. This analysis not only solidifies the es- timator's theoretical foundation but also offers practical insights into its behavior in finite-data and asymptotic regimes.
Ep ED D)
F(O; DI]] <<
where the expectation is over the (random) choice of D
Under this relaxed notion, we still obtain a similar control the expected suboptimality gap:
Theorem 4 (Expected e-Stability of the Minimum). Sup- pose F(: is e-stable in expectation with respect to F(; D). Let
The section structured as follows: first ($5.1), we derive correlation between the accuracy of the performance es- timator and the quality of the minimum found by solving an optimization problem using that performance estimator as objective function; second ($5.2), we study the asymp- totic properties of the performance estimator as the dataset size approaches infinity, formalizing it as an unbiased esti- mator; and finally ($5.3), we demonstrate that our perfor- mance estimator behaves in expectation within e-bound
m" min F(0; D) and M(D) = min F(0; D)
dee
Then
m ED M [D)] S
Hence, even if stability only holds on average, the expected gap between the global optimum on D and the optimum on remains most c.
8

---

Efficient Evolutionary Merging on Consumer-grade GPUs
5.2. Part II: Theoretical Guarantees for MP-IRT
Table 2. Comparison of Evolve methods by number of trials, esti- mated total time on a single NVIDIA 4090, sample size used for Fitness computation, and final accuracy on GSM8K. The number of trials is the result of population size x iterations, parameters of the Genetic Algorithms each method, and represents the total number of merged models evaluated during the entire Evolve run.
We now apply these ideas our proposed MP-IRT estima- tor (cf. $3.1). We first show that IPT is asymptotically unbiased, and then combine this fact with Theorem 4 ar- gue that MP-IRT- based minimizers remain close to those that minimize the full-dataset performance measure.
Method
N Nardok
Estimated total time
Sample size
Accuracy
Asymptotic unbiasedness. The following proposition establishes that, as D grows, 2Mp-IRT converges in proba- bility to the true performance Z. Its proof relies on classical limit arguments for unbiased estimators.
Fvol M.JP-7B
1000
62 days
1000
0.49
MERGE
175
21h
100
0.42
MERGE
12h 20m
50
0.38
MERGE
175
10h 30m
30
0.38
MERGE
175
10h 155m
20
0.34
Proposition 5 (Asymptotic unbiasedness of MP-IRT), As- sume: (i) X + À in probability as | - oc, (ii) for each i E I, the true values a,, Bt, 0,,00,0, 02 are known, with supier ||as|12 I c for a fixed (iii) linear inheritance of abilities (cf. Assumption 1) holds. Then, for all 1,4,
average remains small (say, 2 ?), then the true expectation is also small. Consequently, Theorem implies that the op- timal solution on each D, within é of the global optimum on D, on average.
1 Zz Yiol....,YY..l - E| Yiat...., Yua]] + 0
in probability as [o] + co. Thus, for sufficiently large subsets D, the discrepancy between 2m and Zm can be made arbitrarily small with high probability.
Conclusion. In summary, MP-IRT inherits asymptotic consistency from p-IRT while requiring only a subset π) C D. By showing it is c-stable (in expectation) for large [D], we conclude that optimizing on D yields (on average) a solution close to the true optimum on D. In finite-sample regimes, multiple random draws of D can be used to em- pirically verify that the discrepancy remains small, thereby justifying the practical use of MP-IRT on moderately sized subsets.
5.3. Part III: performance preservation via MP-IRT
We now conclude that MP-IRT preserves near-optimality when we train on a suitably large D C D. Since Propo- sition 5 asserts that Ž approximates Z well for large [D], it follows (under mild conditions) that MP-IRT remains e- stable in expectation. Hence, Theorem 4 shows that min- imizing 2 on D yields, on average, a solution within of the dull-datase optimum.
6. Technical Details
We summarize the GPU timing results for MERGES in table 2, comparing evaluation and merge times across dif- ferent hardware setups. These findings highlight the prac- tical feasibility of our approach even on older GPUs. For additional experimental details refer to appendix C.3.3.
Theorem 6 (Asymptotic performance preservation of MP-IRT). Let D D be a random subset used to compute mmp-IRt Suppose that, as [D] + oo, m converges in probability to Z (the true performance on D), and thut 2mp- HRT is e-stable in expectation for sufficiently large DD) Then the expected global optimum of mIp-IRT on D differs from that of Z on D by at most e. As ID| oc, O.
7. Conclusions
We introduced MERGE3, an evolutionary merging frame- work that makes high-quality model merging feasible on single consumer GPU. By combining subset-based ap- proach with IRT-driven performance estimation, MERGE3 reduces merging costs by up to fifty-fold compared to prior methods without sacrificing the quality of the merged model. Our experiments demonstrate successful cross-lingual transfer in mathematics (e.g., from English to Japanese), as well the synthesis of new multilin- gual models that outperform each of their language-specific endpoints. Overall, MERGE' expands the practical reach of evolutionary merging, allowing everyday practitioners to benefit from advanced multi-task and multilingual model compositions at a fraction of the usual computational cost.
Finite-sample analysis via the Law of Large Numbers. In practice, we rarely have [D] - x. Instead, one can appeal to expected c-stability (Theorem 4) and then esti- mate the corresponding expectation empirically. For in- stance, one may draw multiple subsets DI.....Di Ds at ran- dom from D and compute
$ () - D.):
Σ S
1
as empirical approximation to Ep [IF(O) F(0; D)]] By the Law of Large Numbers, if this empirical

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Impact Statement
2990567. URL http://dtt..cc//et/ doi. www.ooorrr/.ooo..ooooooooooooooo wwogrr//000 1109/
ACCESS 20.. 2990567.
The introduction MERGES provides an efficient and accessible method for evolutionary model merging on consumer-grade GPUs. By combining dataset reduction techniques and Item Response Theory (IRT)-based perfor- mance estimations, MERGES significantly lowers compu- tational requirements while maintaining competitive per- formance. This enables researchers and developers to syn- thesize high-quality multilingual and cross lingual models without requiring cluster-scale hardware.
Brzezińska, J. Item response theory models in the measure- ment theory. Communications in SkatisticsSSimllati and Computation, 49(12):3299-33111 2020.
Bäck, T. and Schwefel, H.-P. An overview of evolution- ary algorithms for parameter optimization. Evolutionary Computation, 1(1):1-23, 1993. doi: 10.1162/evco.199) 1.1.1.
The open-source release of MERGE* aims to make evolu- tionary model merging widely accessible, fostering further innovation in essource-constrinnet environments. With ap- plications in multilingual NLP and low-resource language modeling, MERGES addresses practical challenges in the field, offering an efficient solution for creating statc-of-the- art models on standard hardware.
Cai, L., Choi, K., Hansen, M., and Harrell, L. Item re- sponse theory. Annual Review of Statistics and Its Appli- cation, 3:297-321, 2016.
Clark, P. Cowhey, I., Etzioni, O., Khot, T., Sabharwal, A., Schoenick, C., and Tafjord, O. Think you have solved question answering? try arc, the A12 reason- ing challenge. CoRR, abs/1803.05457, 2018. URL http: /ttp:///axiivv./ org/ abs /10...1133... 05457.
ACKNOWLEDGMENTS
We acknowledge ISCRA for awarding this project access to the LEONARDO supercomputer, owned by the EuroHPC Joint Undertaking, hosted by CINECA (Italy). We also acknowledge support from Sapienza University of Rome, under project BEAT (Better dEep leArning securiTy) and through the Seed of ERC grant "MINT.AI".
Cobbe, K., Kosaraju, V., Bavarian, M., Chen, M., Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano, R., et al. Training verifiers to solve math word problems. arXiv preprint arXiv:21 10. 14/68//688 2021.
Crisostomi, D., Fumero, M., Baieri, D., Bernard, F,, and Rodolà, E. cm Cycle-consistent multi-model merg- ing. In Advances in Neural Information Processing Sys- tems, volume 37, 2025.
References
Ainsworth, S., Hayase, J., and Srinivasa, Git Re- Basin: Merging models modulo permutation symme- tries. In The Eleventh International Conference Learning Representations, 2022.
Dasgupta, D. and Michalewiez, Z. Evolutionary algo- rithms-an an overview. Evolutionary algorithms in engi- neering applications, pp. 3-28, 1997.
Akiba, T., Shing, M., Tang, Y.. Sun, Q., and Ha, D. Evolu- tionary optimization of model merging recipes. Nature Machine Intelligence, Jan 2025. ISSN 2522-5839, doi: 10. 10.100888442556--2440009553 URL pestps://dol org/10. 1038 42256- 02 00975-8.
Davari, M. and Belilovsky, E. Model breadcrumbs: Scal- ing multi-task model merging with sparse masks. In Eu- ropean Conference on Computer Vision, pp. 270-287. Springer, 2025.
Deb, K., Pratap, A., Agarwal, S., and Meyarivan, T. A fast and elitist multiobjective genetic algorithm: Nsga-ii. IEEE Transactions Evolutionary Computation, 6(2): 182-197, 2002. doi: 10. 10.1109/4235.99600
Alves, D. M., Pombal, J., Guerreiro, N. M., Martins, P. H., Alves, J., Farajian, A., Peters, B., Rei, R., Fernandes, P. Agrawal, S., Colombo, P., de Souza, J. G. C., and Martins, A. Tower: An open multilingual large lan- guage model for translation-related tasks. In First Con- ference on Language Modeling, 2024. URL https: //openreview net / for um? - EeSnnEHHnn3
Deb, K., Sindhya, K., and Okabe, T. Self-adaptive simu- lated binary crossover for real-parameter optimization. Proceedings of the 9th Annual Conference on Ge- netic and Evolutionary Computation, GECCO '07, pp. 1187-1194, New York. NY, USA, 2007. Association for Computing Machinery. ISBN 9781595936974, doi: 10. 1145/1276958.1177199 URL https: : ///////d.../ org/ 10. 10.1145/1276955 1277199....7....
An, X. and Yung, Y.-F. Item response theory: What it is and how you can use the irt procedure to apply it. SAS Institute Inc, 10(4):364 2014, 2014.
Blank, J. and Deb, K. Pymoo: Multi-objective opti-
mization in python. IEEE Access, 3:89497-89509 2020. ISSN 2169-3536.
Eiben, A. and Smith, J. Introduction to Evolutionary Com- puting. Springer, 2015.
doi: 10.1109/accss..2000
10

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Gao, L., Tow, J., Abbasi, B., Biderman, S., Black, S., DiPofi, A., Foster, C., Golding, I.,, Hsu, J., Le Noac'h, h, A., Li, H., McDonell, K., Muennighoff, N., Ociepa, C..
Lalor, J. P. and Rodriguez, py-irt: A scalable item re- sponse theory library for python. INFORMS Journal on Computing, 35(1):5-13, 2023.
Phang, J., Reynolds, L., Schoelkopf, H., Skowron, A., Sutawika, L.,, Tang, E., Thite, A., Wang, B., Wang. K., and Zou, A. A framework for few-shot language model evaluation, 07 2024. URL https: https://zeeooii /ttp///eoodooooo//////..ooo.. org/ records 1200660
Lalor, J. P., Wu, H., and Yu, H. Building an evaluation scale using item response theory. In Proceedings of the Conference Empirical Methods in Natural Language Processing. Conference Empirical Methods in Natu- ral Language Processing, volume 2016, pp. 648. NIH Public Access, 2016.
Gargiulo, A. A., Crisostomi, D., Bucarelli, M. S., Scarda- pane, S., Silvestri, F., and Rodola, F. Task singular vec- tors: Reducing task interference in model merging. In Proc. CVPR, 2025.
Lin, S., Hilton, J., and Evans, O. TruthfulQA: Measuring how models mimic human falsehoods. In Muresan, S., Nakov, P., and Villavicencio, A. (eds.), Proceedings of the 60th Annual Meeting of the Association for Compu- tational Linguistics (Volume 1: Long Papers), pp. 3214- 3252, Dublin, Ireland, May 2022. Association for Com- putational Linguistics. doi: 10.186533v1/2022..a.// 229. URL https: /ttp//alaaattttt/ta /ttp://aaannoolloorrg////// acl-long 229/.
Goddard, C., Siriwardhana, S., Ehghaghi, M., Mey- ers, L., Karpukhin, V., Benedict, B., McQuade, M., and Solawetz, J. Arcee's MergeKit: A toolkit for merging large language models. In Demnn- court, F., Preotiuc-Pietro, D., and Shimorina, A. (eds.), Proceedings of the 2024 Conference on Em- pirical Methods in Natural Language Processing: In- dustry Track, pp. 477-485, Miami, Florida, US, November 2024. Association for Computational Lin- guistics. doi: 10. (0.18653/1120224.mmml cmm.////..../ypiiuuuttty... 36. URL https://aclant: emn 1 p- lllp--intttryy... 36/.
Lord, F., Novick, M., and Birnbuum, A. Statistical theories of mental test scores. 1968.
Matena, M. and Raffel, C. Merging models with fisher- weighted averaging.
org/2024.
Minut, A. R., Mencattini, T., Santilli, A., Crisostomi, D., and Rodolå, E. Mergenetic: a simple evolutionary model merging library, 2025. URL https: /ttp//aaxvvv..o/..//. abs/2505.1142.
Ilharco, G., Ribeiro, M. T., Wortsman, M., Gururangan, S., Schmidt, L., Hajishirzi, H., and Farhadi, A. Editing models with task arithmetic. The Eleventh International Conference on Learning Representations, 2022.
Ortiz-Jimenez, G., Favero, A., and Frossard, P. Task arith- metic in the tangent space: Improved editing of pre- trained models. Advances in Neural Information Pro- cessing Systems, 36, 2024.
Jiang, A., Sablayrolles, A., Mensch, A., Bamford, C., Chaplot, D., de las Casas, D., Bressand, F., Lengyel, G., Lample, G., Saulnier, L., Lavaud, L., Lachaux, M.-A., Stock, P., Le Scao, T., Lavril, T., Wang, T., Lacroix, T., and El Sayed, W. Mistral 7b. arXiv preprint arXiv:2310.06825, 2023. URL attps://arxtt org/ htg//bs//20 2580..6855.
Peña, F. A. G., Medeiros, H. R., Dubail, T., Aminbei- dokhti, M., Granger, E., and Pedersoli, M. Re-basin via implicit sinkhorn differentiation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 20237-20246, 2023.
Jordan, K., Sedghi, H., Saukh, O., Entezari, R., and Neyshabur, B. REPAIR: REnormalizing permuted acti- vations for interpolation repair. In The Eleventh Interna- tional Conference on Learning Representations, January 2023.
Petersen, N. S. et al. Using item response theory to equate scholastic aptitude test scores. 1982.
Pétrowski, and Ben-Hamida, S. Evolutionary algo- rithms. John Wiley & Sons, 2017.
Joulin, A., Grave, E., Bojanowski, P., and Mikolov, T. Bag of tricks for efficient text classification. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Pupers, pp. 427-431. Association for Computa- tional Linguistics, April 2017.
Polo, F. M., Weber, L., Choshen, L., Sun, Y., Xu, G., and Yurochkin, M. tinybenchmarks: evaluating Ilms with fewer examples. In Forty-first International Conference on Machine Learning. 2024.
Kingston, N. M. and Dorans, J. The feasibility of using item response theory as a psychometric model for the gre aptitude test. ETS Research Report Series, 1982(1): i-148, 1982.
Real, E., Aggarwal, A., Huang, Y., and Lc, Q. V. Regu- larized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intel- ligence, volume 33, pp. 4780 4789, 2019.

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Sakaguchi, K., Bras, R. L.., Bhagavatula, C., and Choi, Y. Winogrande: An adversarial winograd schema challenge at scale. Communications of the ACM, 64(9):99-106, 2021.
Farhadi, A., Carmon, Y., Komblith, S., and Schmidt, L. Model soups: averaging weights of multiple fine- tuned models improves accuracy without increasing in- ference time. In Chaudhuri, K., Jegelka, S., Song, L.,, Szepesvari, C., Niu, G., and Sabato, S. (eds.), Pro- ceedings of the 39th International Conference on Ma- chine Learning, volume 162 of Proceedings of Ma- chine Learning Research, pp. 23902- PMLR, 17- 23 Jul 2022. URL https: /ttpttp::://rrreee http:///occcdddeo ing...g.... .ag.mll........................m press 62 wowrtsmmm222..hta...
Shoemake, K. Animating rotation with quaternion curves. SIGGRAPH Comput. Graph., 193):245-254, July 1985.
ISSN 0097-8930. doi: 10.11455325165.325222 URL ht https: /tt.///ii/////// www.ooog//oooo..o 0......11533225555 325242..
Stoica, G., Bolya, D., Bjorner, J. B., Ramesh, P., Hearn, T., and Hoffman, J. Zipit! merging models from differ- ent tasks without training. In The Twelfth International Conference on Learning Representations.
Yadav, P., Tam, D., Choshen, L., Raffel, C. A., and Bansal, M. mirging Resolving interference when merging models. In Oh, A., Naumann, T., Globerson, A., Saenko, K., Hardt, M., and Levine, S. (eds.), Advances in Neural Information Processing Systems, volume 36, pp. 7093- 7115. Curran Associates, Inc., 2023.
Thellmann, K., Stadler, B., Fromm, M., Buschhoff, J. S., Jude, A., Barth, F., Leveling, J., Flores-Herr, N., Köhler, J., Jäkel, R., and Ali, M. Towards cross-lingus Ilm eval- uation for european languages, 2024.
Yang. E., Wang, Z., Shen, L.., Liu, S., Guo, G., Wang, X., and Tao, D. Adamerging: Adaptive model merging for multi-task learning- In The Twelfth International Con- ference on Learning Representations.
Van der Linden, W. J. Handbook of item response theory: Three volume set. CRC Press, 2018
Vania, C., Htut, P. M., Huang, W., Mungra, D., Pang, R. Y., Phang, J., Liu, H., Cho, K., and Bowman, S. R. Comparing test sets with item response theory. In Zong, C., Xia, F., Li, W., and Navigli, R. (eds.), Pro- ceedings of the 59th Annual Meeting of the Associa- tion for Computational Linguistics and the 1 11th Interna- tional Joint Conference on Natural Language Process- ing (Volume 1: Long Pupers), pp. 1141-1158, Online, August 2021. Association for Computational Linguis- tics. doi: 10.186633w122021aacccoooo 92. URL https: //aclanthologye www.:llloooooo////ooooo wrtp acl -log..ng...... 92/-
Yang, E., Shen, L., Guo, G., Wang, X., Cao, X., Zhang, J., and Tao, D. Model merging in llms, milms, and beyond: Methods, theories, applications and opportunities. arXiv preprint arXiv:2408.07660 2024a.
Yang, E., Shen, L., Wang, Z., Guo, G., Chen, X., Wang, X., and Tao, D. Representation surgery for multi-task model merging, In Salakhutdinov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp. F. (eds.), Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 56332-56356.. PMLR, 21-27 Jul 2024b. URL https: /ttp://e///ccceeeeggs//. mir www..pree......m.......... www.s/evss3. 2ttps//s/223//yyg222.tttt
Vincent, A. M. and Jidesh, P. An improved hyperparameter optimization framework for automl systems using evolu- tionary algorithms. Scientific Reports, 13(1):4737, 2023.
Yu, L., Yu, B., Yu, H., Huang, F,, and Li, Y. Lan- guage models are super mario: Absorbing abilities from homologous models as free lunch. In Salakhutdi- nov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp, F. (eds.), Proceed- ings of the 41st International Conference on Ma- chine Learning, volume 235 of Proceedings of Ma- chine Learning Research, pp. 5275555557777 577755..RR...... 21- 27 Jul 2024. URL https: http///ooeeeddde mlr. press/v235/ gtess/v233/yu24p.. html.
Wang, K., Dimitriadis, N., Ortiz-Jimenez, G., Fleuret, F., and Frossard, P. Localizing task information for im- proved model merging and compression. In Salakhut- dinov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp, F. (eds.), Proceed- ings of the 41st International Conference on Ma- chine Learning, volume 235 of Proceedings of Ma- chine Learning Research, pp. 50268-50287. PMLR, 21- 27 Jul 2024. URL ht pww.eedince.g.e.eeee mlr. ppess/v235/ 2 4k. html.
Zellers, R., Holtzman, A., Bisk, Y., Farhadi, A., and Choi, Y. HellaSwag: Can a machine really finish your sen- tence? In Korhonen, A., Traum, D., and Marquez, L. (eds.), Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 4791- 4800, Florence, Italy, July 2019. Association for Compu- tational Linguistics. doi: 10. 10.18653/V1//19--4477 URL
White, C., Zela, A., Ru, R., Liu, Y., and Hutter, How powerful are performance predictors in neural architec- ture search? Advances in Neural Information Processing Systems, 34, 2021.
Wortsman, M., Ilharco, G., Gadre, S. Y., Roelofs, R., Gontijo-Lopes, R., Morcos, A. S., Namkoong, H.,
12

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Zhou, L., Solombrino, D., Crisostomi, D., Bucarelli, M. S., Silvestri, F., and Rodolå, E. Atm: Improving model merging by alternating tuning and merging. arXiv preprint arXiv:241..00055 2024.
Table 3. Overview of supported merging methods in Mergenetic.
Method
Multi-Model
Uses Base Model
Linear (Model Soups)
Yes
No
Zhuang, Y., Liu, Q. Ning, Y., Huang, W., Lv, R., Huang, Z., Zhao, G., Zhang, Z.,, Mao, Q. Wang, S., et al. Efficiently measuring the cognitive ability of Ilms: An adaptive testing perspective. arXiv preprint arXiv:2306. 10512, 2023.
SLERP
No
Yes
Task Arithmetic TIES
Yes
Yes
Yes
Yes
DARE (TIES)
Yes
DARE (Task Arithmetic)
Yes
Yes
A. Mergenetic
using library developed specif- ically for this paper, which will be released open-source software, called Mergenetic (Minut et al., 2025). This li- brary allows for defining a merging problem as either a single-objective or multi-objective optimization problem, where one only needs to specify the merging method,a fit- ness function, and select the hyperparameters for a chosen evolutionary algorithm.
Each experiment
The implementation relies Mergekit (Goddard et al., 2024) for merging the models, Pymoo (Blank & Deb, 2020) for optimizing the objective function through evo- lutionary algorithms, and EvaluaaiionHaarees (Gao et al., 2024) for implementing some of the fitness functions. In table 3 outline the supported merging methods, while in table 4 we outline the currently available evolutionary al- gorithms.
We believe this library is significant contribution as it fa- cilitates evolutionary model merging and aligns well with the paper's 's approach, which aims to reduce computational burden. be a valuable tool for the community and for users interested in gross-lingual transfer or creating multi- lingual models for target low-resource languages.
B. Additional Details
This section provides additional implementation and exper- imental details that were not included in the main paper.
B.1. IRT Fitting Details
As previously stated, we used the implementation from Polo et al. (2024) and adopted their configuration set- tings. Specifically, we used Tm N 1/u, ag ~ NN,, 14, 1/u, and 8, N 1/u3). Fol- lowing Polo et al. (2024), we also applied (hyper)priors to the prior parameters using the software for fitting hierar- chical Bayesian models (Lalor & Rodriguez, 2023): B. (O, 10), u, ~ ((1,1), Po ~ N(0, 10), u, ~ I(1, Pa ~ N(0, 10), and ug ~ I(1, For both the model and seample-specifee parameters Yma ai and 3, we take
13

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Table 4. Overview of supported Pymoo's evolutionary algorithms
Table 5. Mistral-based models with shortened column headers and names. Role can be either E, M or B, referring to endpoint, merge or base model respectively. Spee refers instead special- ization, with mth, ger, ita, jpn, dut and gen referring to Math, German, Italian, Japanese, Dutch and General respectively. Wc finally have the author and model ID as per the Huggingface.
in Mergenetic.
Algorithm
Class
Objective(s)
Constraints
Genetic Algoridhm
GA
single
Differential Evolation
DE
single
Biased Random Key GA
BRKGA
single
Nelder Mead
NelderMead
single
Role
Spec
Author
Model
Patiem Search
PatternSearch
single
CMAES
CMAES
single
F mth
upaya07
Art Prrttho2-Maataal--
Evolutionary Strategy
ES
single
mth, 1pn
SakanaAI
EvoLDM-JJ--11-1
SRES
SRES
single
mth mth meta-math
GAIR
Abel-7R-C02
Netakath-Kiistral-
ISRES
ISRES
single
B
gen mistralai
Xistral-78-v0.1
NSGA-II
NSGA2
multi
ger Iphme
em em..eerma..mistze...
R-NSGA-II
RNSGA2
multi
ger
LeoLM
Leo-mistzaal-teesiiens---
NSGA-III
NSGA3
many
ita
DeepMoun100
Mistral Ita 7b
U-NSGA-III
UNSGA3
many
jon
augmaat
shisa-gamma-7bb1
R-NSGA-III
RNSGA3
many
X
duc
Bram Vanroy
GBITje-
MOEAD
MOEAD
many
10
OpenLLM-Ro
BoKistral Instruct
AGE-MOEA
AGEMOEA
many
M
gen
chiee 10
330-Me-ge-Mi
C-TAEA
CIAEA
many
gen
liminerity
x7-7b
RVEA
EMOA
EMS-
RVEA
many
many
E
gen
gen
gen
yam pal-peleg
PracticeLLM
upstage
Experimert26-78
S0LAR-10.78-v1..
gen
1hyu13
L8Cecxtsi1-20.77-.
gen
FuseAl
#usechat-7a-Slerp
M
gen
FuseAl
FuseChat 73 TA
gen
Fusehl
3. 1-5-TB--ixxtaa
their point estimates as the means of their respective vari- ational distributions. The y model dimensionality is set to 15 following the parameter choice suggested by Polo et al. (2024).
gen
FuseAl
SpenChat-3.5-185 -Blaar
gen
jon
aupermario-sleerp-n
F.
gen
jon-hq
eupermarro-slerppx2
gen
jun fuj
aspermario-v2
gen
superlazycoder
Moura
gen
OpenPipe
mistral-ft--peiizeee--22
E
gen
mlahunne
B.2. Experimental Details
Models. One key assumption of model merging is that the endpoint models lie within the same basin (Ilhareo et al., 2022). This means that merging arbitrary mod- els is not feasible; rather, all models involved must be fine-tuned versions of the same base model. To satisfy this requirement, we selected several fine-tuned models from the Hugging Face Hub that originated from the same base model. Specifically, we focused on models fine-tuned starting from Mi Mistra177B (Jiang al., 2023), follow- ing common best practices in the community (Akiba et al., 2025). Table 5 lists all the models used in our experiments, along with their corresponding names on the Hugging Face Hub. A total of 27 models were considered for our experi- ments.
B.2.1. CROSS-LINGUAL TRANSFER
In the cross-lingual transfer evolutionary merging, we evolved four merged models with mathematical capabili- ties in different languages: Japanese, Romanian, German, and Dutch. In each of these experiments, we deployed an ad- hoc genetic algorithm for single-objective optimization. We employed the Simulated Binary Crossover (Deb et al., 2007) operator to generate offspring solutions by combin- ing parent solutions. To maintain diversity and explore the search space, we applied Polynomial Mutation (Deb al., 2007), which introduces small perturbations to offspring solutions and enhances the algorithm's 's ability escape lo- cal optima. This combination of SBX and PM effectively balances exploration and exploitation, facilitating efficient convergence toward optimal solutions.
Number of models. The initialization step. shared across all evolutionary algorithms, involves sampling merging configurations (c.g., interpolation coefficients) and ap- plying them to merge the endpoint models. Conse- quently, MERGES requires the same number of models as any standard merging approach.
Furthermore, guided by empirical tests, we decided to de- ploy SLERP evolve solutions for the Romanian and Dutch problems, while we used a combination of TIES and DARE for the Japanese and the German ones. We deployed four different sizes of the fitness datasets for Japanese, namely 20, 30, 50, and 100, in order to obtain a more detailed analysis of the method for comparison with the work of (Akiba et al., 2025). On the other hand, we kept the fitness dataset size fixed to 20 for all other aforemen-
In the rest of the section, we provide further details for re- producing the experiments in section 4.2 and section 4.4 of the main paper.
14

---

Efficient Evolutionary Merging on Consumer-grade GPUs
tioned experiments. The fitness dataset was extracted from the test set of GSM8K, and used the remaining, non- overlapping samples as test set for evaluating the model. To get the language-specifee versions of GSM8K, we used Unbabel 1 Tower I wuw.rrr-tttrrrtee 2 (Alves et al., 2024) to translate the datasets. In each experiment, the pop- ulation size was fixed to 25 and the number of iterations to 7.
Table 6. Notation used in the paper.
Notation
Description
D
Full dataset.
D
Reduced subset dataset.
D,
Subdataset for task
Latent abilities of model
T
True latent abilities of model m.
(papp)-I Nin [mp-pmp)- Tmm
Latent abilities of model m via P-IRT ability estimator.
Latent abilities of model m via MP-IRT ability estimator.
To check the correctness of the solution, following Akiba et al. (2025), we used regex to extract the last numeri- cal value returned in the model's answer and compare it with the ground truth. The solution is also checked to be in the correct language with the language identifier from fastText (Joulin al., 2017).
04.
IRT parameters related dataset item
Interpolation coefficients for latent abilities.
A. á
MLE of aforementioned parameters. IRT model for dutapoint and model m. IRT model for datapoint i and model parametrized by MLE estimators of o, 8,
Pim
Prom
m
Merged lunguage model.
Yum gaa-aee
Sample-ler level correctness of model m for example i.
The mathematical models used in combination with TIES and DARE were Abel-7B-002 and Ari (ichmo2-Missraa---- SLERP. Moreover, we employed the following language-specializze models: thisa-gaama-7l--V em.german www.rmammisstrr..llo.. GEITje-7B-ultra, and -nr-b-Innnttttt.. More information about these models can be found in 5.
Merged performance estimator MP-IRT.
Generalized merged performance estimator GMP-IRT.
F(m)
Fitness value of a model m.
whereas we used in combination with
Parumeters being optimized in evolutionary search. Pareto front defined by function's F and data
Pro
Global optimum D.
Global optimum
N
Number of samples in the dataset.
B.2.3. ABILITY AND PERFORMANCE ESTIMATOR
Lastly, we evaluated EVoLLM-JP-v1-72 (Akiba et al., 2025) under the same conditions as MERGES to assess its accuracy, following the prompting structure outlined by Akiba et al. (2025).
In these experiments (reported in section 4.1 and section 4.1) we used the test set of the stan- dard version of GSM8K, HellaSwag, ARC, Winogrande, and Truthful Furthermore, we used 6 different models to test the different performance of the ability and performance es- SOLAR-tai1-10. 7B--10.7--Mere-vi/ TBseChat-7B-Slees 130-Merrge-Misrra17,, FuseChat-7B-Ta, and These models were chosen as already available the Open LLM Leaderboard.
B.2.2. MULTI-LINGUAL TRANSFER
In this experiment, we tackle the ARC dataset in multiple languages (Italian, Dutch, German, and English)² (Thell- mann et al., 2024) using multi-objective evolutionary merging procedure based this time on NSGA-II (Deb et al., 2002). We configure the population size to 25 and the num- ber of evolutionary iterations to 7. We deployed a combi- nation of TIES and DARE as merging strategy. As in pre- vious settings, both the fitness function and the test metrics operate by extracting the final model-generated choice via regex, but this time they look for an instance from the set {A, B. C, DJ rather than a number. On top of this, we employed a dataset composed by 20 datapoints for each language from the relative translation of ARC to compute the fitness, and we extracted the test set for the previous experiments. Furthermore, unlike the single-objective ap- proach described earlier, here we explicitly optimize mul- tiple objectives simultaneously. This time, the employed models are Mistral-Ita-7h GEITje-7B-ul- ra, ra, leo-mist ra www.sssrraasessssaaaaaaaaaaaaeae Mistral-7B v0.1.
timator:
SauralPipe-7B-sleee
supermario-slerp-v..
C. Additional Experiments
We report here additional experiments and analyses.
C.I. Extract Step
In the extract step outlined in section 3.1, random sampling has been proposed as the main method to subsample the dataset D C D. While we explored various dataset sub- sampling strategies, we ultimately opted for uniform ran- dom sampling, as our experiments showed that more com- plex approaches offered significant advantage over this simpler method. In this section we report some of the experiments behind this decision and the two alternative methods tried in the extraction step: IRT Clustering (IRT), introduced by Polo et al. (2024), and a custom Representa- tion Clustering (RC) method.
and the base model
WW used the dataset the Hugging Face Hub from openGPT-XXarex
15

---

Efficient Evolutionary Merging on Consumer-grade GPUs
C.I.I. IRT CLUSTERING
m's performance on the full dataset D fraction of the computational cost.
Given a dataset D and the parameter of a fitted IRT model and 3, one can define low-dimensional embedding of each datapoint i E D by E, [av1] [l.... Therefore, IRT- clustering obtains a representative subset by first obtaining a clustering over this embedding space through K-Means, and then choosing the points closest to the centroids as rep- resentative samples.
A schematic overview of the full process is outlined in al- gorithm 2.
Algorithm 2 Representation Clustering Extractor
Require: Dataset D, Endpoint Models my,... May De-
sired subset size K
Ensure: Subset of size K with weights w,;
C.1.2. REPRESENTATION CLUSTERING
1: for i in D do
Let 1m be the set of endpoint models, and let D
2:
E, 6
{=x) be our full dataset. For each sample T4, we first
3:
for m. in {m mn) do
4:
E'm f- embed with model m
encode into a high-dimensional vector by concatenating model-specific embeddings. Concretely, we compute:
E, E-
end for
1 T Σ
7: end for
Eij- T: t=1
Bigs E ER"
8: {E,)Ee + PCA((E))EED)
9: Apply k-means clustering to {EiiED, obtaining K centroids {c+]
where E. is the embedding of the t-th token of sample D, under model mj, and T; is the number of tokens in 24. We form the concatenated representation:
10: For each cluster k. select the closest example i = arg minlen |[E C&
I1: Let C2 (i E D arg me, ) || c* be the set of examples in cluster A:
E [E,1 E1211 ... [[ R
12: Assign weights Waz
[Cel for h: = 1,... K [D]
Since E, can be very high- high-dimensional. we apply Princi- pal Component Analysis (PCA) to project E, onto a lower- dimensional space:
13: return
{itz Wat k=1
K
E. ( & d. Next, apply k-means clustering to the reduced embed- dings [
C.1.3. EXPERIMENTS
To compare the performance of the Sample Extractors, we followed a procedure similar to that described in sec- tion 4.1, computing the absolute estimation error for each extractor. For random sampling, the accuracy estimator obtained via uniform averaging, whereas for IRT and RC it was obtained via weighted averaging. We evaluated the estimator in two different settings: (1) merging math model with a language-tuner tuned model (similar to the cross- lingual setting of section 4.2) for several languages (Italian, German, Romanian, Dutch) and testing the extractor on the corresponding translations of GSM8K (see fig. 8), and (2) merging several math models and testing the extractor on the English version of GSMSK (see fig. 9).
min K
min Σ
[ -c&ll 12
[C 1=1 1skSK
where Cj is the centroid of the k-th cluster. This partitions the dataset into K clusters, each capturing a distinct region of the representation space. From each cluster k we se- lect the representative sample Ziz whose embedding E.; is closest to the centroid c
= arg min EC
[| - -ccl,
Focusing on fig. 8, we see that performance variability is somewhat higher (larger error bars) due to different language-specific datasets. Even so, Random sampling never falls behind IRT or RC, especially for small sample sizes. By the time the subset size reaches 50 or more exam- ples, all three methods converge comparable accuracy- error levels, underscoring the robustness of Random sam- pling. Instead, in fig. 9, the trends are broadly similar for RC and Random sampling, while slightly worse for IRT. Again, as the dataset sample size grows, overall error drops and the gap among methods narrows.
where Cs is the set of samples assigned to cluster k. To ap- proximate the full-dataset metrics from the selected subset D = { k Ik=1- we assign a weight to each representa- tive sample. Since the size of the cluster Cj indicates how prevalent that region of representation space is, we define wi; = |Cal
[D] These weights ensure that the contribution of each representative sample to the overall metric reflects the true proportion of samples that it represents in the original dataset. By evaluating a new model m only on D and us- ing (wx;) ) to calculate a weighted average, we approximate
16

---

Efficient Evolutionary Merging on Consumer-grade GPUs
121
18-
Chanetic
118
Jnd
Figure 8, Extractors across Languages: Absolute error of the estimated accuracy Sample Extractors, averaged across merges of language-specific and English Math finetunings of Mastral I, evaluated on translations of GSMB and presented a function of the number of dataset samples.
(ean))
Figure 10. Ability Estimator languages: Euclidean distance (lower is better) between estimated and true abilities for different languages.
Supplag HII
Takial Chatctigg
8.44
11
116-
Figure 9, Extractors across Merges: Absolute eтror of the esti- mated accuracy of Sample Extractors, averaged across merges of English Math models based on Mist (attral---vv 1. evaluated on GSMBK and presented as a function of the dataset sample size.
Figure 11. Ability Estimator over languages: Cosine similarity (higher is better) between estimated and true abilities for different languages.
To sum up, the Random sampler can sometimes lag slightly behind the more sophisticated IRT and RC. Nevertheless, neither of these methods has clear advantage over the others. Given its simplicity and negligible overhead, the Random strategy stands out highly practical choice for dataset tubsampling-especiiie provements of more complex methods do not clearly justify their added complexity.
when the marginal im-
tor being significantly closer to the ground-truth one com- pared the ability vector estimated by pIRT and gp-IRT. Similarly, we report the corresponding cosine similarity in fig. 11, confirming much higher similarity in case.
C.2. Estimation step
C.2.1. ADDITIONAL EXPERIMENT FOR ABILITY ESTIMATOR
C.2.2. ADDITIONAL EXPERIMENT FOR PERFORMANCE ESTIMATOR
We report in fig. 10 the Euclidean distance between the estimated and ground-truth ability vectors across differ- ent sample sizes. The results are consistent with the case 10, 20 seen fig. 4, with our estimated ability vec-
We report in fig. 13 the evaluation of performance estima- tors across Ainogrande and He lalaawa,, extending the results in fig.
17

---

Efficient Evolutionary Merging on Consumer-grade GPUs
point models, é x Σm= Cm. and use this as the parameter for the merged model's GMP-IRT.
CORDE
Lodking
Results Discussion We evaluate the absolute estimation error across five benchmarks, comparing the adaptive aver- aging strategy for (denoted by *) to the baseline fixed heuristic e = Results for GMP-IRT and GP-IRT", along with the baseline models GMP-IRT, GP-IRT, MP- IRT, and P- P-IRT, are reported in table 7.
Vinngrazle
Vinograede
Vinngrazie
Tratstulaa
Figure 12. Ability Estimator over tasks: Cosine similarity (higher better) between estimated and true abilities for different tasks.
Table 7. Absolute estimation error across datasets. The symbol indicates the adaptive strategy described above. Lower is better.
Vinagrande
Dataset
GMP-IRT"
GMP-IRT
GP-IRT"
GF-IRT
MP-IRT
ARC
0.035
0.040
0.046
0.049
0,048
Winogrande
0.018
0.031
0.032
0.037
0.036
GSM8K
0.057
0.057
0.074
0.064
0.062
HellnSwag
0.046
0.056
0.077
0.071
0.047
Number Semples
Number Sample
TuthfulQA
0.040
0.045
0.062
0.055
0.044
p-IET
SPIRT
zip IRT (cua)
stap JRT (occs)
Bizioon
Across most datasets, the adaptive coefficient strategy yields consistent improvements in both GMP-IRT and GP- IRT, with the largest gains observed on Winogrande and HellaSwag. Notably, GMP-IRT with a tuned performs on par or better than any other method across all benchmarks.
Figure 13. Performance Estimators over Winogrande and Hel- laswag, Absolute error of various estimators as a function of sam- ple size (lower is better). gmp-IRT consistently achieves lower error.
C.2.3. HYPERPARAMETER ANALYSIS FOR PERFORMANCE ESTIMATOR
C.2.4. SPEARMAN CORRELATION
Following White al. (2021), we report the Spearman cor- relation between the ground-truth ranking and the rank- ing induced by each estimator's predictions. We compare the best merging-specific estimator, GMP-IRT, against the strongest vanilla baseline, GP-IRT. The results, averaged across dataset sizes and types, are shown in fig. 14. No- tably, GMP-IRT achieves the highest correlation in each setting, further underscoring the benefits of using estima- tors specifically designed for the model merging context.
We now analyse the optimal choice of the scalar e required in GMP-IRT and GP-IRT (see eq. (5)). In the experiments reported in the main paper (section 4.1) and above (ap- pendix C.2.2), we used as heuristic = 2. Despite its empirical effectiveness, this uniform interpolation may not be optimal across all model pairs and data regimes. There- fore, we introduce grid-search-bue based strategy to estimate an improved value of e and empirically validate its poten- tial reduce estimation error.
C.3. Evolve Step
Methodology. We propose a two-step approach to select- ing the optimal interpolation coefficient for use in the GMP-IRT estimator. The procedure is follows:
C.3.1, ADDITIONAL EXPERIMENT FOR MULTILINGUAL EVOLUTION: COMPARISON WITH IN IN-CONTEXT LEARNING
A natural question when evaluating merging-based meth- ods is how their performance compares to inference-time adaptation strategies such as In-Context Learning (ICL.. In particular, given access to a small validation set, one might ask whether directly providing these examples as input con- text evaluation time can match the performance achieved through evolutionary merging.
1. Optimizing e for Endpoint Models For given dataset D we find a E [0, 1] by minimizing the absolute estimation error of GP-IRT on each individ- ual model. This yields a set of optimal coefficients CM, one for each endpoint model M.
2. Averaging for the Merged Model. To obtain a suit- able interpolation coefficient for GMP-IRT, we com- pute the average of the optimal values across the end-
To investigate this, we evaluate a 20-shot ICL. setup in the multilingual transfer setting introduced in section 4.4. Prompts are constructed using 20 validation examples and prepended to the input at inference time. We apply this setup to two merging baselines, TIES-DARE, and Task
Such dataset is available because it relies solely on the cor- rectness of the endpoint models' answers, rather than the un- known answers of the merged model.
18

---

Efficient Evolutionary Merging on Consumer-grade GPUs
Sires
framework for measuring its prevalence in merged multi- lingual models. We then present analysis of negative transfer in GSM8K.
6,83
0.233
0.99
Sparmann (1
0.51
0.51
11:20
Methodology We consider a multiple-choice question (MCQ) evaluation setup, where knowledge is operational- ized as model's ability to correctly answer a question. Let mi, 172, mk denote the set of K endpoint models, and let m represent the merged model resulting from their combination. Following earlier notation (see table 6), correctness for given sample is defined as a binary vari- able:
Accoess Ticke
0.93
0.52
0.54
10.54
0..7
Spromman
Vim, E {0, 1): indicates whether endpoint model my answers sample i correctly,
6.44
Yum E {0, 1}: indicates whether the merged model answers sample i correctly.
0.0
ABC
GSMRK
HelaSwan
Trahhii
Wasgrarde
GMIARRT
GF-IIT
We define negative transfer example i occurring when at least of the base models answers correctly, but the merged model fails:
Figure 14. Spearman rank correlations using the appendix C.2.3 setup. Higher is better. GMP-IRT shows substantially higher cor- relation than GP-IRT.
jj E {L....,K} such that Yi,, and Yı,
Arithmetic, and compare the results against our method us- ing GMP-IRT with fitness dataset of size 20. Across all
To track this, introduce binary indicator variable ni for each input:
Table 8. Accuracy on multilingual ARC using few-shot ICL. (20- shot) versus MERGES (GMP-IRT-20),
71 = [1, if (Aj Yi,; and Ys, O, 0, otherwise.
Method
DE
IT
NL
EN
TIES-DARE Few-shot (20)
0.227
0.226
0.227
0.226
Finally, we compute the Negative Transfer Rate (NTR) as the proportion of examples exhibiting negative transfer among those for which at least one base model answered correctly:
Taas Arithmetic Few-shot (20)
0.427
0.406
0.491
0.566
MERGE (GMP-IRT-20)
0.720
0.690
0.690
0.790
languages, 3ERGE3 significantly outperforms the ICL- augmented baselines. While ICL can provide moderate im- provements over the original models, it increases inference- time memory usage and latency due to the expanded con- text. In contrast, the merged models produced by our method operate without additional overhead and are imme- diately deployable as standalone networks.
N 1=1
n
NTR ΣN I (1,..., K) Vim, =
This metric provides lask- perspective on the poten- tial degradation introduced by merging and complements the aggregate performance measures reported in the main paper.
C.3.2. ADDITIONAL EXPERIMENT FOR CROSS-LINGUAL EVOLUTION: ANALYZING NEGATIVE TRANSFER
Results Discussion We compute the NTR using the same experimental setting described in section 4.2. As shown in fig. 15, MERGE* consistently yields substantially lower negative transfer than SLERP, TIES, and Task Arithmetic across all languages. This indicates that MERGE" not only improves average accuracy but also preserves correct knowledge from its component models, thereby maintain- ing per-example competence during merging.
While main analysis focused on cross-lingual transfer of MERGE3 (section 4.2), we did not explicitly examine the phenomenon of negative transfer; that is, cases where merging degrades performance on specific inputs. In this subsection, we formally define negative transfer in the con- text of multiple-choice questions (MCQs) and introduce
19

---

Efficient Evolutionary Merging on Consumer-grade GPUs
0.97
0.57
0198
Table 9. Throughput (R) models per hour for different sample sizes per fitmess evaluation on GSMEK. These estimates are based on 12- 12-hour Evolve runs on single NVIDIA 4090 with 24GB VRAM.
0.88 (1/0)
2,15
Sample size
1000
100
50
30
20
Dands
Tommsian
Throughput (Models/Hour)
0.67
8.33
14.17
16.67
17.08
MIRIGES
SLERP
'IA
Figure 15. Negative Transfer Rate across languages. Lower is bet- ter. MERGE* shows substantially less negative transfer than stan- dard baselines.
Table 10. Evaluation and merge time across different GPU models using Mistral-7B on examples (4-bit, SLERP).
GPU Model
Eval Time (s)
Merge Time (s)
C.3.3. ADDITIONAL EXPERIMENT: TIME & FLOPS REQUIREMENTS EVOLUTIONARY MERGING
NVIDIA 3090 24GB
65
135
NVIDIA 4090 24GB
45
160
NVIDIA V100 32GB
80
220
Hardware Setting. To compare the efficiency of dif- ferent model evaluation strategies, we measured the time required to evolve merged LLM models using a single NVIDIA 4090 with 24GB VRAM, and report the Throughput R table We also benchmark evaluation and merging times across three GPU models (3090, 4090, V100) to illustrate practical runtimes for MERGE' on both modern and older hardware. We report the results in ta- ble 10
brary*. This script has been used to estimate the FLOPs for the experiment in Figure
D. Mathematical proofs
We outline in table 6 a scheme of the notation used through- out the paper.
Results Discussion. Over 12-hour period, we were able to evaluate 8 models on 1000 samples of GSM8K with single NVIDIA 4090, allowing us to estimate that evalu- ating 1000 models would take approximately 62 days un- der similar conditions. In contrast, MERGES enabled the evaluation of larger number of merged models in sig- nificantly less time by using reduced dataset. These re- sults suggest that researchers and practitioners could lever- age consumer-grade GPUs for efficient LLM merging and evaluation, making rapid experimentation of model merg- ing methods more accessible. We report in table the es- timated total time the Evolve runs, which we calculated using the following formula:
D.1. Proof of Theorem 2
Proof. Let m == F(0"; D) and m = F(0; D). We must show that m - m S 6.
1. By e-stability, for all 0 E O:
F(0; D) F(O; D)
In particular, for 0 0"
F(B": D) F(8":D) s c.
Hence
N Noddels
:))":D) 2 F(0": D)
T T(Nmodees))
R Raatsset Size
and
F(O;;)) D) I F(0; + e.
Lastly, table 10 shows that MERGE3 maintains practical runtimes across range of GPUs. While the 4090 of- fers the fastest evaluation, older hardware like the V100 still supports feasible experimentation, highlighting the framework's 's accessibility and the generalizability of results across different consumer GPUs.
2. Since 0 is the minimizer of F(; D), we have
F( < F(0"; D). Because 0* is the minimizer of F(; D),
F(O: D) 2 F(0"; D).
FLOPs Calculation. We provide a Jupyter Notebook that describes the FLOPs calculations for our experiments in the supplementary material, based on the cale-flops li-
httpl:::///ittuu..oo////tee falculatee-
20

---

Efficient Evolutionary Merging on Consumer-grade GPUs
3. To bound in m, can add and subtract F(0"; D)
where m² mingee P(0; D). Meanwhile, by min-
to have
versus-expectation (Jensen-type) inequality,
m = (F(0: D) F :D) + (F(Or: D))
Eplmin min F(0; []] Σ 8E0
minE D)
BEB
Hence,
The first term is S 0 (since i is a minimizer on D), and the second term I e. Hence
Ep mD)) Ep min F(;; D)]
WEee
2 min E pl ((; (0: D)] 2 m - c.
m I ++
#EB
Combining these two bounds results in
4. Analogously, to bound m, we can rewrite
m m = (F(Or - F(0:D))
m' - S [p[m(D)] I m +
+ (F( F(O:D))
and, therefore,
m Eplm(() 1 c.
The first term is S 0 (since 8* minimizer on D), and the second term S e. Thus,
m S -+E=
D.3. Proof of Proposition
5. Combining these incqualities:
Proof. We must show that
-E S m S E = Im ml S e.
E 2zz Yo. Yi,1] Zz Yigh...., YY.]]
Hence |F(0"; F(O; s completing the proof.
in probability as |7] - co. Under the assumptions of the proposition (including linear inheritance of abilities, Å + À in probability, and bounded [|a:]]) [)), we may bound this difference as follows:
D.2. Proof of Theorem
E 2 | Yiot...,, Yidl E|Zzi Yigh. Y.al
Proof. By hypothesis, for every 0 E O,
1- í
Σ |0((i10), + 22001) Ta - -.)
ED[1F(0:D) Di]
[1 Tl
&ETSI
Using Jensen's inequality for the absolute value,
a - 8i)
ED|F((; D) F)]: - (D F(0: S e.
Since is 1/4 1/pshiic on IR we have
= 1
((hrd). + +2g((s) 0lm) T Tasl
Hence,
[1
vei,
- Eg((()D) ((0))) S
Jaiilaa 11(200, + )20())))) 0m1l12
for each fixed 6. thus follows that
Ep[F(0: D)] < F)!:D) +e
Since suptel, ||a:|l2 < it follows that
and
S <c][(A- - (1)( + (d2 x2) 0tal12 112 +
ED[F(0: D)] F(0, -..
Consequently,
in probability as | + oc. (The last step uses + A in probability, with 6,,, 01, fixed in Rd) .) Hence 2,, converges in probability to Zyt, completing the proof.
min Ep[F(B; D)] < min [F(; t = m² +., #E
#Eo
21

---

Efficient Evolutionary Merging on Consumer-grade GPUs
D.4. Proof of Theorem 2
Proof. By Proposition 2up-Iit becomes arbitrarily close (in probability) to Z [D] Under standard regularity conditions, this implies
(0; D)
7mp-IRT (D:
in expectation, for all sufficiently large [D] hence IRT e-stable in expectation. Applying Theorrm completes argument.
22


Reviews:
[{"review_id": "MDRbCMzbNU", "reviewer": "Reviewer_sVdP", "summary": "The authors present a framework for efficient evolutionary merging of language models for creating models with strong multi-task and/or cross-lingual task performance from a library of existing fine-tuned models without additional fine-tuning. In MERGE$^3$, the critical efficiency benefit comes from Extracting (in this case, randomly sampling) a much smaller sample of examples for different tasks from full datasets. Latent ability vectors are then iteratively Estimated for each model on different tasks via Item Resposne Theory, and these IRT-based estimators are used to inform optimal merges for each iteration. The authors conclude that MERGE$^3$ results in models that are competitive with an evolutionary merging algorithm that relies on full evaluation at each step.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thank you for the detailed and thoughtful review. Your feedback helped us identify key areas for clarification. Below, we respond to each point.\n\n**Claims And Evidence**\n\n- In the revision, we’ll replace “while preserving performance” with: 50× compute reduction with ~86% accuracy retained (e.g., Japanese GSM8K). The 50× figure reflects general FLOP savings; the 86% retention is task-specific and may vary. We’ll clarify this distinction to avoid overstatement.\n- We will clarify the GPU used for the experiments in the main manuscript, and specify minimum VRAM requirements. We used an RTX 4090, with Batch Size 8, Quantization 4bit, Model size 7B.\n\n**Methods And Evaluation Criteria**\n\n- Please refer to W1.\n\n### Weaknesses\n\n- **W1 — true wall clock time**: We agree that FLOPs don’t fully capture runtime efficiency. We’ll include wall-clock breakdowns of Estimate and Evolve steps, as well as end-to-end timing per MERGE³ iteration. To clarify: both MERGE³ and EvoMerge load the same models, so load time is similar; the gain comes from evaluating fewer examples, which significantly reduces total runtime. We’ll support this with empirical data.\n- **W2 — clarity issues:**  We now use *i* for data examples and *j* for models to remove ambiguity. “Endpoint model” is defined at first use, and MP-IRT/GMP-IRT are spelled out with brief explanations. Assumption 1 does not imply a latent space of dimension |D|, but that a merged model’s ability is a linear combination of endpoint abilities. We’ll clarify its role further in the revised paper.\n- **W3 — finetuning baseline**: Unfortunately, full fine-tuning of a 7B model on ARC isn’t feasible within the rebuttal. We also note that this experiment has substantially different requirements from our budget-friendly MERGE3 framework, which is specifically designed for consumer-grade hardware and operates using only a small number of datapoints (20). That said, we agree this comparison would be valuable and plan to include it in the final version.\n\n### Comments\n\n**C1 — changing title:** we’ve updated the abstract to explicitly mention that our method targets **language models**, which we agree improves clarity. Regarding the title, we’ll aim to revise it to include “evolutionary *model* merging” for the camera-ready version, subject to the venue’s guidelines on title changes. \n\n**C2 — emphasizing fitness as a key bottleneck**: We revised the introduction to highlight that **fitness evaluation is the main bottleneck** in evolutionary merging.\n\n**C3 — GPU specification**: Please see the “claims and evidence” section. \n\n**C4 — wall-time**: Please see the answer to W1. \n\n**C5 and C6 —** **Clarifying notation:** Thanks for pointing out this lack of clarity. Please refer to the answer to W2. \n\n**C7 — Aligning axes in figures:** we will align the axes and scales across grouped figures so that all plots use consistent increments in the revised version of the paper. \n\n### Questions\n\n**Q1 — Merging in Data Flow Space (DFS)**: We tried DFS merging as in Akiba et al., but found no consistent gains. Their Table 1 shows DFS often underperforms parameter space (PS) merging, despite adding 3B parameters—nearly half the base model. Given our focus on efficiency for consumer GPUs, this overhead was impractical, so we prioritized size-preserving strategies.\n\n**Q2 — Estimated total time**: It is a measure based on up to 12 hours runs for each method on a single NVIDIA 4090. This is an end to end measure of the entire pipeline: including model loading, estimation of abilities, and evolution of models. \n\n**Q3 — understanding of Estimate vs Evolve**: Yes, that’s correct. **Estimate** is run once to compute endpoint abilities using the full dataset. **Evolve** then runs iteratively, using only the reduced dataset and our estimators to evaluate new merged models efficiently. \n\n**Q4 — scaling of compute requirements**: We agree this is an important consideration and will include a discussion in the paper. In MERGE³, **Estimate** is run once per endpoint model on the full dataset, while **Evolve** runs repeatedly on a reduced subset. In practice, **Evolve dominates compute** because:\n\n1. **Correctness labels are often public** (e.g., Open LLM leaderboard), making Estimate nearly free. \n2. **Estimate is one-time**, whereas Evolve runs over many generations and a full population. \n\nWhen correctness must be computed manually, a rough rule of thumb is: **if** M × N > P × K (where M = endpoint models, N = full dataset size, P = population, K = reduced subset), then Estimate might dominate. Otherwise, Evolve is the primary cost. \n\n**Q5 — dimensionality of the latent ability vectors**: The dimensionality is a hyperparameter; we set it to **16**, following TinyBenchmarks [1]. \n\n**Q6 — see W1**\n\nWe thank you again for your valuable feedback. We remain available for any further questions or clarifications.", "claims_and_evidence": "The paper's claims are generally supported when they are are concrete and specific. To me, however, it feels like a stretch to state that the algorithm \"reduc\\[es\\] fitness computation costs 50x **while preserving performance**\". In my opinion, it would be better to state objectively the % of accuracy performance preserved at the fraction of compute used. Additionally, the concrete example and general description (at least VRAM capacity) of the consumer GPU used should be included earlier than in the Appendix.", "methods_and_evaluation_criteria": "Overall yes, though some aspects of presentation could be improved for fairness and clarity. I would have liked to see wall-clock training time results presented in the main body -- presumably there might be some amount of overhead from loading in models and data such that naive estimation from FLOP counts may be insufficient", "theoretical_claims": "Seems correct, but I have some issues with clarity (see below)", "experimental_designs_or_analyses": "seems sound and valid.", "relation_to_broader_scientific_literature": "Main related work seems to be the Akiba et al Evolutionary Model Merging paper, where the key contribution over that paper is to use only a much smaller subset of dataset examples to estimate latent model ability.", "essential_references_not_discussed": "n/a", "other_strengths_and_weaknesses": "Strengths:\n1. Reported effiicency gains are significant and do indeed enable an approximation of a method that is prohibitively expensive if performed naively\n2. Interesting use of item response theory in the context of model merging\n3. Proposed framework is supported by both empirical results and theoretical grounding\n\nWeaknesses:\n1. See Questions 2-4. I have some uncertainty about the true wall-clock compute savings that result from using MERGE$^3$. I am thinking of e.g. potential overhead from repeated loading of different models into VRAM. Though these numbers are dependent on the specific GPU, model, and amount of data, I would feel better about accepting the \"50x\" figure with some kind of breakdown of specific amount of time needed for each framework step (and for each end-to-end iteration of Evolve)\n2. Some clarity issues throughout, especially in the Section 5 theoretical analysis. See Comments 5-6 below\n3. Missing baseline , See Q6", "other_comments_or_suggestions": "1. Consider updating the title to have \"Evolutionary **Model** Merging\", and specifically mentioning language models in the abstract\n2. In the intro, somewhere between \"In this paper\" and \"Our approach\", I would have liked to see it explicitly stated that fitness computation is a key bottleneck in the standard evolutionary merging approach that is being compared to. Though it is clear looking back, it could help with clarity on a first read\n3. \"Consumer GPU\" can mean many different things -- I think it would improve the specificity of the authors' claims to state explicitly the kind of GPU that was used and what kind of VRAM it has, earlier in the main body. Currently it is only implied that the specific device that benchmarking was performed on was a 4090, and GPU's capacity is not stated until the appendix.\n4. I would have liked to see something like Table 7 in the main body\n5. I would strongly prefer avoidance of using the same $i$ to index variables repeatedly. It sometimes refers to examples in $\\mathcal{D}$ (e.g. under Eq.1), but it sometimes seems to refer to models in the pool (e.g. in Eq. 3). Is Assumption 1 meant to imply that the dimension of the latent ability vectors must equal $|\\mathcal{D}|$?\n6. Please define \"endpoint model\" before using it, and spell out MP-IRT and GMP-IRT the first time it appears\n7. In general, aligning axes/scales across figures in the same group would help with clarity. For Figure 4 in particular, going from 0 to 1.0 in the same increments would be helpful", "questions_for_authors": "1. Did the authors try any merging in data flow space as Akiba et al did?\n2. What exactly is meant by \"Estimated total time\" in Table 7? Does this only account for Evolve runs (not Estimating?)\n3. Relatedly, is my understanding of Estimate vs Evolve correct? I understand Estimate as an initial, more complete computation of estimated ability in the initial candidate pool of models. Estimate is only performed once. Evolve, then, also covers iterative updating of performance estimator parameters via repeated inference on the *reduced* set of examples from the Extract step -- is this correct?\n4. Can the authors provide a discussion of scaling of compute requirements as datasets, set of tasks, and/or models grow, especially wrt Estimate vs Evolve? e.g. is there some order of magnitude of dataset size at which the compute requirements of Estimate could be expected to dominate Evolve?\n5. What is the expected dimensionality of the latent ability vectors?\n6. In Table 1, authors provide a baseline of translated ARC performance on models only fine-tuned for the language. Are there baselines for translated ARC performance on models fine-tuned only for ARC? Additionally, I understand that this is not always practical, but in this case it seems possible to provide a baseline of translated ARC performance on models fine-tuned on the translated ARC datasets, along with information about compute requirements for the same. This would help us understand whether MERGE$^3$ is expected to pareto-dominate even a direct fine-tuning approach when sufficient training data is available", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "tTkIP3YeXD", "reviewer": "Reviewer_ysfV", "summary": "This paper introduces MERGE3, a framework for efficient evolutionary model merging on consumer-grade GPUs. The method addresses computational bottlenecks in evolutionary merging by: (1) extracting a reduced dataset for evaluation, (2) estimating model abilities using Item Response Theory (IRT), and (3) evolving optimal merges via IRT-based performance estimators. The authors assert MERGE3 reduces fitness computation costs by 50× while preserving performance.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank you for your thoughtful and detailed review. We are glad you find our framework coherent, our theoretical underpinnings solid, and our empirical results convincing. Below, we address your specific points and questions. \n\n**Limited analysis of hyperparameters:** The main hyperparameter in our pipeline is the interpolation coefficient **c** (Equation 5), for which we followed the default from TinyBenchmarks [1] without tuning.\n\nFollowing the reviewer’s suggestion, we ran a hyperparameter sweep over **c**. The results (included in the revised paper) show that while our original methods—**MP-IRT** and **GMP-IRT**—already outperformed competitors, the tuned **GMP-IRT*** further improves performance\n\n| Dataset | GMP-IRT* | GMP-IRT | GP-IRT* | GP-IRT | MP-IRT |\n| --- | --- | --- | --- | --- | --- |\n| ARC | **0.035**  | 0.040  | 0.046  | 0.049 | 0.048 |\n| WINOGRANDE | **0.018**  | 0.031  | 0.032  | 0.037 | 0.036 |\n| GSM8k | **0.057** | 0.057  | 0.074  | 0.064 | 0.062 |\n| HELLASWAG | **0.046** | 0.056  | 0.077  | 0.071  | 0.047 |\n| TRUTHFULQA | **0.040**  | 0.045  | 0.062  | 0.055  | 0.044 |\n\nFor the **evolutionary run**, we used 175 individuals, split into 25 subpopulations over 7 iterations—chosen to ensure all experiments completed in under 24 hours. While not extensively tuned, this setup balanced runtime and performance well.\n\n**Ablation studies:**  Because evolutionary search is inherently noisy and computationally expensive to run many times end-to-end, the most feasible way to measure each module’s impact is to isolate it and evaluate it independently. In Figure 3, we focus on performance estimators, while Figure 4 examines ability estimators. Additional ablation results are included in Appendix C.2 and C.3. We agree these analyses are crucial, and we will add a concise summary of them in the main text to more clearly highlight each component’s contribution. \n\n**Benchmarks limited to one GPU.** We will include multi-GPU benchmarks in the revised paper to better illustrate MERGE³’s accessibility. Below is an example using Mistral-7B on GSM8K-RO (10 examples, 4-bit models, SLERP merging):\n\n| **GPU** | **Eval Time** | **Merge Time** |\n| --- | --- | --- |\n| 3090 24GB | 65s | 135s |\n| 4090 24GB | 45s | 160s |\n| V100 32GB | 80s | 220s |\n\nThese times show MERGE³ is practical even on older GPUs. We will add more results in the final version, including how runtimes scale with GPU class and batch size.\n\n### Weaknesses\n\n**W1 — negative transfer:** In our updated experiments, we study **negative transfer** in cross-lingual merging using the DE, NL, RO GSM8K dataset and compare the **Negative Transfer Rate (NTR)** of MERGE3 against SLERP, TIES, TA. Negative transfer is observed when the merged model fails to answer a question correctly despite at least one base model having answered it correctly. Namely, `NTR = (# of negatively transferred questions) / (# of questions at least one base model got right)`\n\n| Language | MERGE3 (↓ better) | SLERP | TIES | TA |\n| --- | --- | --- | --- | --- |\n| Dutch | **0.38** | 0.95 | 0.96 | 0.96 |\n| Romanian | **0.52** | 0.87 | 0.87 | 0.88 |\n| German | **0.35** | 0.80 | 0.68 | 0.69 |\n\nWe see that MERGE3 substantially reduces negative transfer compared to standard interpolation methods. We will include full details and derivations in the appendix for transparency.\n\n**W2 — additional data reduction strategies**: We agree that exploring non-random sampling strategies is an intriguing direction, and we experimented with two additional methods—an IRT-based clustering approach (as in [1]) and a “Representation Clustering” technique that uses concatenated embeddings from our endpoint models and applies PCA plus k-means. In both cases, we observed no clear performance benefits relative to simpler random sampling, especially after considering the added complexity and compute overhead. Thus, we ultimately opted for random sampling, but we will include these findings (presently in Appendix C.1) more prominently in the final version, highlighting why more sophisticated methods did not yield sufficient gains to justify their complexity. \n\n### Questions\n\n**Q1 — extending to more than two endpoints**: Our evolutionary framework naturally extends to merging more than two endpoint models. The only change is an increase in the dimensionality of the search space, as we optimize more interpolation coefficients. The rest of the pipeline remains unchanged. We maintain a fixed population size (e.g., 25) and apply standard evolutionary operations. We demonstrated this in practice by merging three models for Jap math and four models across IT, EN, NL, and DE in the multilingual setting—both without any changes to the architecture or training procedure. \n\nThank you again for your thoughtful feedback. We're happy to provide further clarification if needed.", "claims_and_evidence": "The paper makes several claims that are generally well-supported:\n1. The 50× reduction in computational cost is demonstrated through calculations and empirical measurements.\n2. Performance preservation is shown through comparisons with models evolved on full datasets.\n3. Cross-lingual knowledge transfer effectiveness is demonstrated through experiments on multiple language pairs.\n\nThe evidence is convincing, particularly the experimental results showing comparable performance to models requiring much greater computational resources.", "methods_and_evaluation_criteria": "The methodology is coherent and properly described. The three-stage approach (Extract, Estimate, Evolve) is logically structured. Evaluation metrics and baselines are appropriate. The authors rigorously evaluate against standard merging techniques (TIES-DARE, SLERP, Task Arithmetic) and compare against state-of-the-art models like EvoLLM-JP-7B.", "theoretical_claims": "The theoretical foundation is solid. The authors provide formal guarantees for their performance estimators.", "experimental_designs_or_analyses": "The experiments are comprehensive but have some limitations:\n1. Good coverage of cross-lingual transfer and multilingual model evolution\n2. Appropriate baselines and metrics\n3. Limited analysis of hyperparameter sensitivity\nAblation studies could be more extensive to isolate the contribution of each component\nHardware benchmarks are limited to a single GPU model (NVIDIA 4090)", "relation_to_broader_scientific_literature": "The paper properly positions itself within the model merging literature. Connections to IRT are well-established, and the authors appropriately attribute previous work", "essential_references_not_discussed": "The literature review is comprehensive, covering key works in model merging, evolutionary algorithms, and IRT.", "other_strengths_and_weaknesses": "Strengths:\n1. Addresses a practical limitation in state-of-the-art model merging\n2. Novel theoretical guarantees for performance estimation\n3. Open-source library implementation\n\nWeaknesses:\n1. Limited discussion of potential negative transfer in cross-lingual merging\n2. Could explore more dataset reduction strategies beyond random sampling", "other_comments_or_suggestions": "1. Consider expanding the analysis to more GPU configurations", "questions_for_authors": "How does your approach extend to scenarios with more than two endpoint models?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "N2PdKcqN1v", "reviewer": "Reviewer_XxKs", "summary": "This paper proposes an efficient evolutionary model merging framework to achieve multilingual model merging and cross-language knowledge transfer, and conducts a large number of experiments and theoretical analysis to verify the effectiveness of the method.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thank you for your thorough evaluation of our work and for highlighting areas in need of clarification. We appreciate the opportunity to provide more detail on our key contributions relative to [1], our assumptions regarding the availability of a validation set, and our comparisons with in-context learning (ICL). Below, we address each of your points in turn.\n\n### Weaknesses\n\n**W1** — **difference with tinyBenchmarks:** We thank the reviewer for pointing this out and agree that it is essential to clarify the difference from [1] (“tinyBenchmarks”). \n\nWhile [1] provides two estimators (pIRT and gpIRT) for efficient *evaluation* of large language models, our work proposes two *new* estimators—mpIRT and gmPIRT—***specifically tailored for model merging***. We demonstrate that plugging these new estimators into the *evolutionary* merging pipeline yields a *fifty-fold* reduction in computational costs, with negligible loss in accuracy. \n\nConcretely, mpIRT and gmPIRT incorporate the *additional prior* we have in the merging setting, namely ***access to all endpoint models’ abilities***. This lets us approximate the merged model’s ability by a *linear combination* of the endpoints’, rather than fitting a full IRT vector from scratch. Doing so drastically reduces the data and compute needed per iteration of evolutionary search, which is the main bottleneck. By contrast, directly applying [1] to merging *without* leveraging this extra prior would require re-fitting a merged model’s IRT parameters each time, significantly slowing down evolution. Thus, although we take inspiration from [1]’s general approach to *efficient performance estimation*, our paper addresses new challenges in model merging, such as evolving interpolation coefficients across multiple tasks/languages and making performance estimators *merging-aware*. \n\n**W2 — Need for a validation set:** We follow the evolutionary merging setting introduced in [2], which assumes a validation (or evaluation) set is available to measure candidate models’ fitness. This convention is also common in other merging works, such as those that use a held-out set to tune the scaling factor [3]. That said, we agree that exploring *fully unsupervised* proxies—e.g., perplexity or entropy on unlabeled data—would be an exciting direction, as it would relax the requirement for supervised validation data in merging. We plan to investigate such approaches in future work.\n\n[1] Polo, Felipe Maia, et al. \"tinyBenchmarks: evaluating LLMs with fewer examples.\" *International Conference on Machine Learning*. PMLR, 2024. \n\n[2] Akiba, Takuya, et al. \"Evolutionary optimization of model merging recipes.\" *Nature Machine Intelligence* (2025): 1-10. \n\n[3] Ilharco, Gabriel, et al. \"Editing models with task arithmetic.\" *The Eleventh International Conference on Learning Representations*. \n\n**W3 — Comparison with In-Context Learning (ICL)** We appreciate the reviewer’s suggestion. To address it, we ran the proposed few-shot in-context learning approach on our multilingual experiments, providing 20 samples as context at inference time for two baselines (TIES-DARE and Task Arithmetic). As shown in the table below, Merge³ significantly outperforms these few-shot baselines on each language: \n\n| Method | DE | IT | NL | EN |\n| --- | --- | --- | --- | --- |\n| TIES-DARE Few-shot (20) | 0.227 | 0.226 | 0.227 | 0.226 |\n| Task Arithmetic Few-shot (20) | 0.427 | 0.406 | 0.491 | 0.566 |\n| Merge³ (gmpIRT-20) [Ours] | **0.720** | **0.690** | **0.690** | **0.790** |\n\nFurthermore, using ICL makes the context significantly longer and increases memory requirements, whereas our merged model has *no additional overhead at inference*. Once we merge the models offline, the resulting single network can be deployed with the same resource footprint as a standard model of that size. Thus, while few-shot ICL can help in certain scenarios, **model merging** provides a more permanent and resource-efficient solution. \n\nWe are grateful for the time and attention you invested in reviewing our paper. Your feedback has been very helpful, and we believe that the clarifications provided address your concerns. We look forward to further refining our work in response to your comments.", "claims_and_evidence": "YES", "methods_and_evaluation_criteria": "YES", "theoretical_claims": "YES", "experimental_designs_or_analyses": "YES", "relation_to_broader_scientific_literature": "This paper significantly improves the efficiency of previous evolutionary model merging[1].\n\n[1] Evolutionary optimization of model merging recipes. Nature Machine Intelligence, 2025.", "essential_references_not_discussed": "Clarify the more specific challenges/differences between [1] and this paper's method.\n\n[1] tinybenchmarks: evaluating llms with fewer examples. ICML, 2024.", "other_strengths_and_weaknesses": "Strengths:\n- This paper proposes an efficient evolutionary model merging framework for multilingual model merging and cross-lingual knowledge transfer.\n- This paper provides theoretical guarantees to verify the effectiveness of the method.\n- This paper is clearly written and provides source code implementation.\n\nWeaknesses:\n- This paper seems to be just an application of [1] to model merging. It is not clear what challenges/difficulties there are in directly applying [1] to model merging, as this seems to be a straightforward application. The authors mention [1] in all subsections of this paper’s methods section, which seems to be a direct extension of [1] in the model merging setting. The authors need to clarify the connection more deeply.\n- This paper relies on a large validation set for data selection, however, in the standard model merging setting, such data does not seem to be available.\n- If validation set data is available, how does the performance compare to the approach of this paper if the available validation data is directly used as input to the test phase of the merged model through in-context learning?\n\n[1] tinybenchmarks: evaluating llms with fewer examples. ICML, 2024.", "other_comments_or_suggestions": "See weaknesses", "questions_for_authors": "See weaknesses", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "Dzp0Fs1ZxC", "reviewer": "Reviewer_iqT4", "summary": "This paper performs model merging using multi-objective evolutionary search that yields Pareto optimal solutions. The fitness function of the evolutionary algorithm requires one to evaluate a given model’s performance several times. The authors propose using a performance estimator using item-response theory (IRT) that can estimate the model’s true performance by only evaluating it on a subset of the data. NSGA-II evolutionary algorithm is employed by Merge3 where each objective is the performance of the merged model on a particular task. They demonstrate that their method is capable of cross-lingual skill transfer. The report the efficacy of their performance predictor using mean square error between the predicted and the true scores.", "questions": "", "limitations": "", "rating": 2, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thank you for your detailed and constructive review. We appreciate your insights and will do our best to address your concerns within the space constraints of the rebuttal.\n\n### Methods and evaluation criteria\n\nWe report Spearman rank correlations (higher is better) using the Figure 3 setup. Due to space limits, we show averages across datasets and sample sizes (10–100); full breakdowns will appear in the paper. Results show that GMP-IRT consistently outperforms GP-IRT in ranking accuracy. \n\n|  | **n=10** | **n=20** | **n=30** | **n=50** | **n=100** |\n| --- | --- | --- | --- | --- | --- |\n| **gmpirt** | **0.54** | **0.68** | **0.73** | **0.83** | **0.84** |\n| **gpirt** | 0.51 | 0.58 | 0.69 | 0.71 | 0.77 |\n\n|  | **arc** | **gsm8k** | **hellaswag** | **truthful** | **winogrande** |\n| --- | --- | --- | --- | --- | --- |\n| **gmpirt** | **0.84** | **0.64** | **0.57** | **0.93** | **0.63** |\n| **gpirt** | 0.77 | 0.59 | 0.48 | 0.92 | 0.51 |\n\n### Experimental design and analyses\n\n**Ada-Merging and EMR Baselines:** Thank you for highlighting these baselines—we agree they are important. Our current setup relies on MergeKit, which doesn’t yet support them. Implementing and optimizing them (e.g., for quantization) is beyond the rebuttal scope, but we plan to add support and include them in the camera-ready or follow-up.\n\n### Weaknesses\n\n**W1 — scaling number of models**: Our approach scales well with the number of endpoint models because its computational cost depends on the population size (25 in our experiments) and the number of evolutionary iterations—both independent of how many endpoints are merged. We do note that the search space grows linearly with the number of endpoints, so more sophisticated initialization or mutation strategies might be needed to ensure efficient convergence.\n\n**W2 — novelty of the estimators:** While inspired by tinyBenchmarks, our estimators (mpIRT and gmPIRT) are tailored for merging. By leveraging the known abilities of endpoint models and assuming linearity, we obtain more efficient *and* more accurate ability estimation—crucial for guiding evolutionary search.\n\n**W3 — Low-Resource Settings & Initialization:** MERGE³ uses the same endpoint models as standard merging methods. The initial population is generated by sampling interpolation coefficients—*not* from additional models. This makes our method equally applicable in low-resource settings, and we’ll clarify this distinction in the paper.\n\n### Comments and questions\n\n**C1:** **Algorithm 1 explanation and position:** We agree Algorithm 1 is central and will move it to the main paper in the camera-ready using the extra page. We'll also add a brief explanation to clarify its key steps.\n\n**Q1 — In-Language Merging:** \n\nWhile our primary focus was cross-lingual transfer, we also investigated merging models **within a single language**—Italian in this case. We merged a math-in-Italian model ([MetaMath-Mistral-7B + Mistral-Ita-7B](https://huggingface.co/DeepMount00/Mistral-Ita-7b)) with a code model with Italian capabilities ([CodeNinja-1.0-OpenChat-7B](https://huggingface.co/beowolx/CodeNinja-1.0-OpenChat-7B)), then evaluated code generation performance on the [MBPP dataset](https://huggingface.co/datasets/google-research-datasets/mbpp) (zero-shot pass@1) and math accuracy in Italian. As shown below, the merged model not only achieves higher code accuracy but also preserves math performance:\n\n| Model | Code Accuracy | Math Accuracy |\n| --- | --- | --- |\n| Merged Model | **0.218** | **0.596** |\n| Math Model | 0.212 | 0.552 |\n| CodeNinja | 0.200 | 0.192 |\n\nThese findings demonstrate that MERGE³ can integrate multiple task-specific abilities within the same language, and we plan to include this experiment in the appendix of the revised paper.\n\n**Q2 — Baselines failure:** We appreciate the reference to [2], which highlights representation misalignment as a major factor in poor performance for standard merging methods. Our baselines typically do not address this issue, so a technique like representation surgery could help reduce bias. While our work focuses on *efficiently* merging models via IRT-based estimators, we view representational alignment as a promising, complementary direction. We will cite [2] in the final version and consider leveraging such approaches to further enhance MERGE³.\n\n**Q3 — Initialization and \"Ad-hoc Genetic Algorithm\":** We randomly initialize the population by creating interpolations of the same endpoint models used by our baselines—no additional models are needed. By “ad-hoc genetic algorithm,” we mean standard evolutionary operators tailored for merging. Specifically, we use **Simulated Binary Crossover** to recombine parents and **Polynomial Mutation** to introduce small perturbations. We will revise Algorithm 1 and the main text to make these steps clearer.\n\nWe thank you again for your valuable feedback. We remain available for any further questions or clarifications.", "claims_and_evidence": "Ya the claims are supported by evidence. But like I pointed out in other sections, there is scope for improvement.", "methods_and_evaluation_criteria": "These make sense\n1. This paper demonstrated its efficacy by merging math models with Romanian, German and Dutch langauge respectively and evaluated the merged model's performance on the GSM8k in the corresponding language. \n2. They evaluate Merge3's performance against the EvoMerge model using the same settings. Despite using 50 times lesser compute, this method yields a model that is only slightly worse than what EvoMerge resulted in\n\nHowever, while evaluating performance estimators, it is important to evaluate the spearman correlation between the true ranking and the ranking of the models based on the estimator. The accuracy of the models might be very close to each other. It is important to demonstrate that the model is able to discriminate between them and rank them correctly. This is a common practice in Neural Architecture Search [1], Hyperparameter Optimization etc. \n\n[1] How Powerful are Performance Predictors in Neural Architecture Search? White et al.", "theoretical_claims": "Ya I checked their proofs on the performance estimators being $\\epsilon$-stable and $\\epsilon$-consistent, MP-IRT being asymptotically consistent and also preserving near-optimality.", "experimental_designs_or_analyses": "Please include Ada-merging and Emr-Merging [1] as baselines \n\n[1] EMR-Merging: Tuning-Free High-Performance Model Merging, Huang et al.", "relation_to_broader_scientific_literature": "Ya this paper provides an evolutionary algorithm based model merging method that reduces the computational burden by using only a subset of the evaluation data.", "essential_references_not_discussed": "N/A", "other_strengths_and_weaknesses": "Strengths\n1. This work proposes a more efficient way to perform evolutionary search and speeds up evomerge by 50 times. \n\nWeakness\n1. Of late, papers such as adamerging, emr-merging etc are merging 8 models each trained on a particular task. Would this method scale to perform well on that task? It would require a lot of more compute as the number of models increase.\n2. The IRT based estimators are heavily borrowed from the tinybenchmarks paper with a slight adaptation to estimate only the interpolation coefficients owing to the nature of model merging. \n3. What about low resource languages where several models are not available to initialize the population?", "other_comments_or_suggestions": "You can spend a paragraph explaining algorithm 1. Also algorithm 1 must be in the main paper and not the appendix.", "questions_for_authors": "1. You have demonstrated on cross-lingual tasks. Can your method outperform the baselines on tasks involving the same language?\n2. Why are other method performing so poorly on these tasks? Would the surgery [2] model alleviate the representation bias in this case?\n3. In algorithm 1, it is not clear how the population is initialized. What is ad-hoc genetic algorithm?\n\n[2] Representation Surgery for Multi-Task Model Merging, Yang et al.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: This paper presents a method for reducing the evaluation time in evolutionary model merging. The proposed method, MERGE^3, extracts a reduced dataset for evaluation and estimates the model abilities using item response theory (IRT). The idea of reducing technique is inspired by existing work of tinybenchmarks. The effectiveness of the proposed method is demonstrated through several model merging experiments.

The effectiveness of the proposed method is supported by experiments and theoretical analysis, which is an advantage of the paper. Also, the open-source library will be useful for the community.

In the original manuscript, there are several unclear and overclaiming descriptions, which have been pointed out by reviewers and adequately addressed in the rebuttal phase. These descriptions should be revised accordingly in the revised manuscript. 

In addition, I encourage you to include the result of the wall-clock training time and the computation breakdown, including the overhead of model loading, in the main text.
Decision: Accept (poster)