What Matters for Model Merging at Scale?

## Abstract

Abstract Model merging aims to combine multiple expert models into a more capable single model, offering benefits such as reduced storage and serving costs, improved generalization, and support for decentralized model development.
Despite its promise, previous studies have primarily focused on merging a few small models. This leaves many unanswered questions about the effect of scaling model size and how it interplays with other key factors—like the base model quality and number of expert models—, to affect the merged model’s performance.
This work systematically evaluates the utility of model merging at scale, examining the impact of these different factors. We experiment with merging fully fine-tuned models using four popular merging methods— 𝙰𝚟𝚎𝚛𝚊𝚐𝚒𝚗𝚐 𝙰𝚟𝚎𝚛𝚊𝚐𝚒𝚗𝚐 \mathtt{Averaging} typewriter_Averaging , 𝚃𝚊𝚜𝚔 ⁢ 𝙰𝚛𝚒𝚝𝚑𝚖𝚎𝚝𝚒𝚌 𝚃𝚊𝚜𝚔 𝙰𝚛𝚒𝚝𝚑𝚖𝚎𝚝𝚒𝚌 \mathtt{Task~{}Arithmetic} typewriter_Task typewriter_Arithmetic , 𝙳𝚊𝚛𝚎 𝙳𝚊𝚛𝚎 \mathtt{Dare} typewriter_Dare - 𝚃𝙸𝙴𝚂 𝚃𝙸𝙴𝚂 \mathtt{TIES} typewriter_TIES , and 𝚃𝙸𝙴𝚂 𝚃𝙸𝙴𝚂 \mathtt{TIES} typewriter_TIES - 𝙼𝚎𝚛𝚐𝚒𝚗𝚐 𝙼𝚎𝚛𝚐𝚒𝚗𝚐 \mathtt{Merging} typewriter_Merging —across model sizes ranging from 𝟷 ⁢ 𝙱 1 𝙱 \mathtt{1B} typewriter_1 typewriter_B to 𝟼𝟺 ⁢ 𝙱 64 𝙱 \mathtt{64B} typewriter_64 typewriter_B parameters and merging up to 𝟾 8 \mathtt{8} typewriter_8 different expert models. We evaluate the merged models on both held-in tasks, i.e., the expert’s training tasks, and zero-shot generalization to unseen held-out tasks.
Our wide range of experiments provide several new insights about model merging at scale and the interplay between different factors. First , we find that merging is more effective when experts are created from strong base models, i.e., models with good zero-shot performance, compared to pre-trained ones. Second , larger models facilitate easier merging. Third merging consistently improves generalization capabilities. Notably, when merging eight large expert models, the merged models often generalize better compared to the multitask trained models. Fourth , we can better merge more expert models when working with larger models. Fifth , different merging methods behave very similarly at larger scales.
Overall, our findings shed light on some interesting properties of model merging while also highlighting some limitations. We hope that this study will serve as a reference point on large-scale merging for upcoming research.

## 1 Introduction

Model merging (Raffel, ) refers to the process of combining two or more *constituent* (*expert*) models to produce a new, and potentially more powerful model. The appeal of this technique is rooted in several benefits it can confer: *first*, it dramatically reduces storage and serving costs by reusing a single model across tasks; *second*, it enables compositional combination of capabilities from expert models, which can improve generalization to novel tasks; and *third*, merging supports decentralized and modular model development by allowing multiple contributors to independently build models and later combine them together.

These characteristics have led to a great deal of recent efforts in developing cost-effective model merging methods (Matena & Raffel, ; Ilharco et al., ; Jin et al., ; Yadav et al., ; Yang et al., ; Yu et al., ; Shah et al., ; Tam et al., ; Zhao et al., ), often using simple *arithmetic operations*, such as averaging the parameters of the constituent models. However, most of these studies are limited to small-scale experiments with relatively small models (typically $<\mathtt{7B}$ parameters) and merging $\mathtt{2}$ or $\mathtt{3}$ experts (Yu et al., ; ), and mainly focus on improving benchmark performance on held-in tasks that the expert models were trained on (Yu et al., ; Yadav et al., ). Despite the promises that model merging holds, the research community still lacks a comprehensive study to evaluate its effectiveness as we scale the model size. Moreover, it is not clear how scale interplays with other factors like number of expert models and base model quality to affect the merged model’s held-in performance and zero-shot generalization.
This is of paramount importance, as models are rapidly growing in size, and more open-weight models and datasets are becoming available,(^1^11As of writing, the largest open-weight AI model is $\mathtt{Llama~{}3.1~{}405B}$ parameters, and Hugging Face hosts a plethora of community-contributed resources, with $\mathtt{1M+}$ models and $\mathtt{200K+}$ datasets.) driving the need for practical and scalable merging methods.

Our primary goal in this paper is to provide insights into the scalability of model merging. While a few studies have explored merging at the $\mathtt{13B}$ parameter scale (Huang et al., ; Yu et al., ; ), they primarily leverage increased model size and combine only $\mathtt{2}$-$\mathtt{3}$ models to attain better performance on held-in tasks. As such, the interplay of factors like model size, base model quality, number of constituent models—and their effect on both held-in and zero-shot generalization performance (held-out)—remains largely unexplored. Hence, we aim to address the following *four* research questions (RQ):

- RQ1:
What is the effect of using *pretrained* vs. *instruction-tuned* base models for creating expert models for merging?
- RQ2:
Does model merging become *easier* or *harder* as the model size increases?
- RQ3:
How does merging affect *zero-shot generalization* to held-out tasks, and how is this influenced by model size?
- RQ4:
How *many* expert models can be merged without performance loss, and how does this depend on model size?

To answer these question, we systematically evaluate the effectiveness of current *state-of-the-art* merging methods through empirical experiments. Specifically, we utilize the $\mathtt{PaLM}\texttt{-}\mathtt{2}$ model (Anil et al., ) and its instruction-tuned variant, $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$, while scaling the model sizes up to $\mathtt{64B}$ parameters. We experiment with four popular merging methods, namely, $\mathtt{Averaging}$ (Wortsman et al., ; Choshen et al., ), $\mathtt{Task~{}Arithmetic}$ (Ilharco et al., ), $\mathtt{TIES}$-$\mathtt{Merging}$ (Yadav et al., ), and $\mathtt{Dare}$-$\mathtt{TIES}$ (Yu et al., ). We conduct a series of sensitivity and ablation experiments to understand the relative importance of several factors like model size ($\mathtt{1B,8B,24B,64B}$ parameters), base model quality (pretrained vs. instruction-tuned), and number of constituent models ($\mathtt{2,4,6,8}$) being merged. Additionally, we consider two axes of evaluation using the T0 data collection (Sanh et al., ): held-in evaluation with tasks the expert models were trained on, and held-out, for zero-shot generalization to unseen tasks.

Figure: Figure 2: Merged experts created from big and strong base models generalize better than multitask models. We find that for strong base models as we merge more experts (x-axis, $\rightarrow$), the merged model’s generalization performance (y-axis, $\uparrow$) monotonically increases to approach and eventually surpasses multitask baseline. (yellow line). More details in Section 4.3.
Refer to caption: x3.png

Our experiment results shed light on the promises of model merging and reveal interesting insights into the behaviors of different factors at scale.
First, we find that the model initialization plays a crucial role in enhancing the performance of the merged model. Specifically, across all evaluation settings, using strong zero-shot instruction-tuned base models to create expert models leads to improved performance compared to using pretrained models (see §4.1).
Second, larger models are consistently easier to merge. This holds true regardless of the base model used (instruction-tuned or not), number of models merged, or merging method (see §4.2).
Third, our
results demonstrate that merging significantly enhances zero-shot generalization, consistently improving the ability to adapt to new tasks.
Notably, when using strong base models as the number of merged experts increases, our merged model either matches or exceeds the performance of a strong multi-task training baseline (see §4.3).
Fourth, larger models are better at merging a larger number of expert models (see §4.4).
Finally, our numerous experiments identify specific settings where we expect model merging to be much more useful. From this we provide general recommendations for practitioners (see §4.6).
Taken as a whole, our findings are a powerful testament to the potential of model merging at scale for creating highly generalizable language models, which we hope will spur more fundamental research into the development of practical and scalable merging methods.

## 2 Background

Model merging has emerged as a cost-effective method for developing improved models. Two common use cases of merging are: (1) combining model checkpoints from different data versions, hyperparameters, or training stages to enhance distributional robustness (Team et al., ; Dubey et al., ), and (2) combining multiple expert models trained on different datasets to leverage their complementary capabilities. In both scenarios, the expert models generally share a common architecture and a base model from which the expert models are created via fine-tuning.

This work focuses on merging specialized, fine-tuned versions (experts) of a single base model to enhance its capabilities. Each expert model is trained on distinct datasets covering different tasks, domains, and/or capabilities. We refer to the tasks/datasets used for training the expert models as “$\mathtt{held}$-$\mathtt{in}$”, while those that are new and unseen are called “held-out”. Our goal is to create a unified model that retains the individual expert models’ capabilities on held-in tasks while improving zero-shot generalization on held-out tasks. This merging approach provides a flexible, modular method for post-training large language models, facilitating the addition of new features and capabilities to top-performing models.

### 2.1 Model Merging Methods

We denote the set of $\mathtt{N}$ expert tasks as $\mathtt{t_{1}},\ldots,\mathtt{t_{N}}$ and the base model weights, representing the common ancestor of all expert models as $\theta_{\mathtt{base}}$.
The weights of the corresponding specialized expert models, each obtained by fully fine-tuning the base model on a specific expert task, are denoted as $\theta_{\mathtt{1}}$, …, $\theta_{\mathtt{N}}$, respectively. We focus on “open vocabulary” models which utilize natural language as input and output for both classification and generation tasks, eliminating the need for task-specific classification heads making the merging process simpler.
Given this, model merging methods can be defined as a function $\mathcal{M}(.)$.
This function takes as input the base model, the set of N expert models, and potentially additional information, denoted by $\Phi$.
This additional information may include activation statistics, Fisher matrices, or other method-specific data.
The output of the function is the merged model, represented by its parameters $\theta_{\mathtt{m}}$.
Formally, $\theta_{\mathtt{m}}=\mathcal{M}(\{\theta_{\mathtt{i}}\}_{\mathtt{i=1}}^{
\mathtt{N}},~{}\theta_{\mathtt{base}},\Phi),\text{where }\Phi\text{ is method~
{}specific~{}data.}$

Given our focus on studying model merging with large models, we select four merging methods based on their popularity and simplicity.
We only study merging methods that can scale to tens of billions of model weight parameters and do not require any additional information to perform merging, i.e., $\Phi=\{\}$, as these techniques are efficient for even larger models.
Other more complex methods that require computing fisher matrices (Matena & Raffel, ), backward passes (Yang et al., ), or additional information like model activation (Jin et al., ) are skipped because of their computational complexities for large scale model merging that we focus on in this work.
Next, we describe the four selected model merging methods in detail.

#### 2.1.1 Averaging

Parameter averaging (Choshen et al., ; Wortsman et al., ) is a well-established technique in federated learning (McMahan et al., ) and recent applications extend its utility to merge models for enhancing model robustness against out-of-distribution data (Wortsman et al., ; Ramé et al., ), refine pre-trained models (Yu et al., ), develop multimodal models (Sung et al., ), and create multitask models by combining capabilities (Yadav et al., ; Ilharco et al., ).
Parameter averaging is achieved by taking a mean of all the expert model weights together without using the base model which can be formally described as, $\mathcal{M}(\{\theta_{\mathtt{i}}\}_{\mathtt{i=1}}^{\mathtt{N}},~{}\theta_{
\mathtt{base}})=\frac{\mathtt{1}}{\mathtt{N}}\sum_{\mathtt{i=1}}^{\mathtt{N}}
\theta_{\mathtt{i}}$.

#### 2.1.2 Task Arithmetic

Task Arithmetic (Ilharco et al., ) introduces a novel concept of “task vectors” for model merging. For task $\mathtt{t_{i}}$, the task vector is denoted as $\tau_{\mathtt{i}}=\theta_{\mathtt{i}}-\theta_{\mathtt{base}}$ which captures task-specific knowledge by quantifying the difference between the fine-tuned expert parameters ($\theta_{\mathtt{i}}$) and the original base model parameters ($\theta_{\mathtt{base}}$). A scaling hyperparameter $\lambda$ controls the contribution of the aggregated task-specific knowledge to the final model. The merged model is then constructed by linearly combining the base model parameters with a scaled sum of all task vectors. Formally, task arithmetic can be described as, $\mathcal{M}(\{\theta_{\mathtt{i}}\}_{\mathtt{i=1}}^{\mathtt{N}},~{}\theta_{
\mathtt{base}};\lambda)=\theta_{\mathtt{base}}+\lambda*\sum_{\mathtt{i=1}}^{
\mathtt{N}}(\theta_{\mathtt{i}}-\theta_{\mathtt{base}})$.

#### 2.1.3 𝚃𝙸𝙴𝚂 𝚃𝙸𝙴𝚂 \mathtt{TIES} typewriter_TIES Merging

$\mathtt{TIES}$-Merging (Yadav et al., ) identifies two main challenges with model merging: ❶ during finetuning expert models accumulate a lot of noise in the parameters, and ❷ different experts might want to change the same parameter in different directions leading to interference/conflict between the expert models.
They demonstrate that both of these factors hurt model merging and propose a three steps process to remove redundant parameters, followed by resolving sign conflicts, and finally aggregating only the parameters that are not conflicting.
Specifically, in $\mathtt{TIES}$ Merging they first zero out the values in each task vector that have low magnitudes to obtain the trimmed task vector $\hat{\tau}_{\mathtt{i}}$ for each task.
Next, they chose the aggregate sign ($\gamma_{\mathtt{m}}$) for each parameter based on whether the parameter has a higher total magnitude in the positive or the negative direction across all trimmed task vector, formally, $\gamma_{\mathtt{m}}=\textrm{sgn}(\sum_{\mathtt{i=1}}^{\mathtt{N}}\hat{\tau}_{
\mathtt{i}})$. Finally, for each parameters $p$ the models whose sign matches the aggregate sign are averaged to obtain the merged task vector. Finally, the merged model is obtained by scaling the merged task vector using a hyperparameter $\lambda$ and then added back to the base model as, $\theta_{\mathtt{m}}^{\mathtt{p}}=\theta_{\mathtt{base}}+\lambda*\frac{\mathtt{
1}}{|\mathcal{A}^{\mathtt{p}}|}\sum_{\mathtt{i}\in\mathcal{A}^{\mathtt{p}}}
\hat{\tau}_{\mathtt{i}}^{\mathtt{p}}\text{,~{}where }\mathcal{A}^{\mathtt{p}}=
{\{\mathtt{i}\in[\mathtt{N}]~{}|~{}\hat{\gamma}^{\mathtt{p}}_{\mathtt{i}}=
\gamma_{\mathtt{m}}^{\mathtt{p}}\}}$.

#### 2.1.4 Dare Merging

Dare (Yu et al., ) extends the idea of $\mathtt{TIES}$ merging by proposing to use a dropout-like pruning stage to remove noise before merging. Specifically, a Bernoulli mask $\mathtt{M_{i}}$ with drop probability $\mathtt{p}$ is applied to each task vector to obtain the pruned task vector $\hat{\tau}_{\mathtt{i}}=(\mathtt{1-M_{i}})\odot\tau_{\mathtt{i}}/(\mathtt{1-p})$. This stochastic process randomly zeroes out elements within the task vector while preserving its expected value. These pruned task vectors are then used along with either $\mathtt{TIES}$ Merging or Task Arithmetic. Due to the popularity of the Dare variant that uses $\mathtt{TIES}$ Merging, we use that to represent the Dare method and call it Dare-TIES.

### 2.2 Challenges/Limitations

Model Merging has been utilized at a growing rate in practice as it has recently been applied to building modern language models like $\mathtt{Llama}$-$\mathtt{3}$ (Dubey et al., ) and $\mathtt{Gemma}$-$\mathtt{2}$ (Team et al., ). However, most formal studies on model merging have been performed with relatively small models. There are a few studies that look at larger models with $\mathtt{7B}$ and $\mathtt{13B}$ parameters. However, those studies mostly focus on merging $\mathtt{2}$-$\mathtt{3}$ models to improve benchmark numbers as opposed to better understanding how the size of the model affects the model merging process and the resultant model. To motivate our work, we present some of the limitations of the existing studies and highlight their difference with our work.

##### Most Studies on Small Models ( < 𝟽 ⁢ 𝙱 absent 7 𝙱 <\mathtt{7B} < typewriter_7 typewriter_B parameters):

Almost all existing model merging papers rarely use large models ($>\mathtt{7B}$).
For example past works (He et al., ; Daheim et al., ; Ortiz-Jimenez et al., ; Jang et al., ), including popular methods like ModelSoup (Wortsman et al., ), Task Arithmetic (Ilharco et al., ) and $\mathtt{TIES}$-Merging (Yadav et al., ), RegMean (Jin et al., ), Fisher-Merging (Matena & Raffel, ) Ada-Merging (Yang et al., ), MatS (Tam et al., ) perform experiments with model families like CLIP (Radford et al., ), ViT (Dosovitskiy et al., ), T5 (Raffel et al., ), DeBERTa (He et al., ), Roberta (Liu et al., ), BERT (Devlin et al., ) with less than $\mathtt{1B}$ parameters.
Hence, it is unclear how well model merging works for large models, what factors play an important role, the effect of model size, number of tasks being merged, and its effect on both held-in performance and generalization of the model.
Some studies hypothesize that bigger models might be easier to merge however there are no concrete large scale studies to thoroughly assess such claims at large scale.

##### Model Merging Studies with Large Models are Shallow:

Some recent works like DARE (Yu et al., ), WIDEN (Yu et al., ), Chat-Vector  (Huang et al., ) demonstrate merging results for larger models with up to $\mathtt{13B}$ parameters, however these studies have a few limitations: ❶ They primarily focus on using model merging to improve model quality and hence their experiments do not provide concrete insights on how model size interplays with merging, ❷ They only merge a maximum of two or three models at once, ❸ They primarily focus on held-in tasks and do not provide any insights on the effect of merging on a model’s generalization abilities. Other works like RewardSoup (Rame et al., ), WARM (), WARP (Ramé et al., ), FuseLLM (Wan et al., ), FuseChat (Wan et al., ) also work with $\sim\mathtt{7B}$ sized models and focus on specific applications of model merging without providing any deeper insight about how merging performance changes for large models.

##### Varied Evaluation Setups:

Most previous works rarely share their experimental setup where both the expert datasets and the objective vary. For example, RegMean (Jin et al., ), Task Arithmetic (Ilharco et al., ), $\mathtt{TIES}$ (Yadav et al., ), MaTS (Tam et al., ) uses GLUE tasks (Wang et al., ), Vision tasks, T0 held-out, and T0 held-in (Sanh et al., ) tasks respectively. Moreover, different works evaluate for different use cases like intermediate task training in Fisher merging (Matena & Raffel, ), robustness in modelsoups (Wortsman et al., ), and held-in performance for Dare (Yu et al., ), both held-in and held-out performance in $\mathtt{TIES}$ Merging (Yadav et al., ). Given our focus on combining model capabilities in the post training phase, we focus on evaluating on both held-in tasks and generalization to unseen held-out tasks.

## 3 Large Scale Evaluation of Model Merging

In this work, we address the limitations mentioned above by systematically understanding the effect of various factors like model size, base model quality, merging method, and the number of models being merged on both the held-in and generalization performance of the final merged model. Next, we describe our experimental design.

##### Data:

Sanh et al. () found that explicit multitask training of T5 (Raffel et al., ) on a collection of prompted datasets produces a model with strong zero-shot performance on unseen tasks. This has become a common experimental setting for benchmarking zero-shot generalization (e.g.  (Longpre et al., ; Jang et al., ; Zhou et al., ; Chung et al., ; Muqeeth et al., ). Hence, we adopt the experimental setting from the T0 mixture (Sanh et al., ) which contains $\mathtt{8}$ held-in and $\mathtt{4}$ held-out task categories. For each of these categories there are multiple datasets in the T0 mixture (Sanh et al., ) and hence to reduce evaluation costs, we select $\mathtt{2}$ datasets from each category based on the popularity and the train dataset size. Specifically, the $\mathtt{8}$ held-in task categories (with a total of $\mathtt{16}$ datasets) include Multiple-choice QA, Extractive Qa, Closed-Book QA, Sentiment Analysis, Topic Classification, Structure-to-text, Summarization, and Paraphrase Identification. Similary, the $\mathtt{4}$ held-out task categories (with a total of $\mathtt{7}$ datasets) are Sentence Completion, Natural Language Inference, Coreference Resolution, and Word Sense Disambiguation. For more details see Section A.

##### Expert Model Creation:

Recognizing the significance of post-training for LLMs where models are typically fully fine-tuned, we perform full fine-tuning to create our expert models to better mimic the post-training setting. Moreover, in post-training phases it is common to first perform Instruction Tuning (IT) on the model before moving on to other steps. Hence, we examine the effect of using strong instruction-tuned base models on the process and outcome of model merging. Given this, we utilize the $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models (Anil et al., ) with sizes $\mathtt{1B,8B,24B,}$ and $\mathtt{64B}$ as our base models ($\theta_{\mathtt{base}}$). To obtain the instruction tuned base model, we further fine-tuned the $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models on the $\mathtt{FLAN}$-$\mathtt{v2}$ dataset (Longpre et al., ) while excluding the T0-mixture tasks (Sanh et al., ). These instruction-tuned variants are denoted as $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$. For each of the $\mathtt{2}$ base model types (non-IT vs IT) and $\mathtt{4}$ model sizes, we perform full fine-tuning on the $\mathtt{8}$ held-in task categories resulting $\mathtt{64}$ specialized experts models which are then used further in our experiments. Comprehensive details regarding hyper parameters and computational requirements are provided in Appendix B.

##### Experimental Setting:

Given our collection of expert models, for each merging experiment we select a subset of expert models which we call the constituent models. We create a large merging experiment grid with $\mathtt{2}$ base models ($\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$), four model sizes $\mathtt{(1B,8B,24B,64B)}$, four Merging methods (Averaging, Task Arithmetic, Dare-TIES, and $\mathtt{TIES}$), the number of constituent models $\mathtt{(2,4,6,8)}$, and $\mathtt{3}$ seeds to randomly select the constituent tasks for the experiment resulting in a total of $\mathtt{384}$ merging experiments. These seeds are shared across different experimental settings to ensure the same tasks are selected across base models, model sizes and merging methods to ensure fair comparison. For example, in an experiment we merged $\mathtt{2}$ expert models, derived from the $\mathtt{64B}$ $\mathtt{PaLM}\texttt{-}\mathtt{2}$ base model with the constituent models being MCQ and Summarization experts while the same experiment with a different seed resulted in Closed Book QA and Sentiment Analysis experts as the constituent models.

##### Evaluation:

For each of the experiments above, we assess the merged model’s performance by evaluating it on both the held-in tasks – i.e., the training tasks of the constituent expert models – and all $\mathtt{4}$ held-out task categories. For example, if the constituent models are MCQ and Summarization experts, then for held-in tasks we evaluate on the MCQ datasets (DREAM and Cosmos QA) and Summarization datasets (CNN Daily Mail and XSum) resulting a total of $\mathtt{4}$ held-in evaluation datasets. Moreover, all merging experiments are also evaluated on the $\mathtt{4}$ held-out tasks categories consisting of $\mathtt{7}$ datasets listed in Appendix A. There we perform approximately $\sim\mathtt{9000}$ model evaluations across all of our experiments.

##### Metric:

Given that different datasets use different metrics, we normalize the performance metrics to make them unitless so that they can be aggregated. For held-in tasks, the merged model’s performance is normalized against the corresponding task expert model’s performance. However, for held-out tasks, the normalization was performed relative to the base model’s performance. We denote this metric as normalized performance throughout the paper.
Importantly, we want to emphasise that this metric is relative, with a value of $\mathtt{1}$ indicating performance comparable to the reference model. Hence, for held-in tasks a value of $\mathtt{1}$ means performance similar to the domain expert model while for held-out tasks it means performance is similar to the base model. We mark this line in most of our figures and specify the models that are used for normalization. Finally, to generate aggregated results, we compute the mean of normalized performance across all datasets within each category, then across all categories and then over the three seeds.

## 4 Experimental Results

In this section, we explore the interplay between model size and key factors such as base model quality, merging method, and the number of constituent (expert) model, along with their effect on both held-in and zero-shot generalization (held-out) performance. Our findings are: ❶ Merging is more effective when the constituent models are derived from instruction-tuned base models rather than pretrained ones (see §4.1); ❷ Larger models facilitate easier merging (§4.2); ❸ Merging significantly improves zero-shot generalization, with instruction-tuned models benefiting from increased constituent models, and larger model sizes allowing the merged model to match or exceed multi-task training (§4.3); ❹ We can merge more models effectively when using larger models (§4.4); and ❺ Different merging methods perform similarly when applied to large-scale instruction-tuned models. Below, we outline the experimental setup and discuss these findings in detail.

Figure: Figure 3: Instruction-tuned models facilitate easier merging. $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ ( •) consistently outperforms $\mathtt{PaLM}\texttt{-}\mathtt{2}$ ( •) as shown by the huge gap between the green point ( •) being higher than red points ( •), across various merging methods, model sizes, and numbers of constituent models, indicating that stronger instruction-tuned base models enhance the performance of merged models. The dashed lines denoted the performance of the experts trained on the held-in tasks as defined in § 3. For more details see Section 4.1.
Refer to caption: x4.png

### 4.1 Instruction-Tuned Models Facilitate Easier Merging

##### Experimental Setup:

Prior research suggests a connection between robust zero-shot models and effective model merging. Wortsman et al. () demonstrate that averaging strong zero-shot models improves out-of-distribution robustness. Ortiz-Jimenez et al. () indicate that effective pretraining allows for weight disentanglement, and thus enhancing merging. Other studies (Yadav et al., ; Ilharco et al., ) propose that strong base models could aid in model merging, though this hypothesis remains largely untested.

To assess how base model quality affects the held-in performance of merged models, we perform merging experiments with fully fine-tuned experts from $\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$. We vary model sizes in $\mathtt{\{1B,8B,24B,64B\}}$ and the number of constituent models in $\mathtt{\{2,4,6,8\}}$. Held-in performance is measured over three trials to minimize the impact of selected expert models and their data distributions. A consistent seed is used across different base models, model sizes, and merging methods to ensure fair task comparisons. We evaluate four merging methods: averaging, task arithmetic, $\mathtt{TIES}$, and Dare-TIES, and also compare against the performance of task-specific expert models.

##### Findings:

Our results, presented in Figure 3, indicate that $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models denoted by green color ( •), consistently outperforms $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models ( •) across various merging methods ($\bullet,\blacktriangle,\blacklozenge,\star$), model sizes (x-axis $\rightarrow$), and numbers of constituent models (subplots). This supports our hypothesis that stronger instruction-tuned base models enhance the performance of merged models. Similar to the findings of Ortiz-Jimenez et al. (), we believe that large-scale instruction tuning further disentangles model weights, facilitating effective model merging and improving the base model’s zero-shot performance.

Figure: Figure 4: Bigger models merge better. On Held-In evaluations, we find that bigger models always perform better compared to smaller models, barring a few outliers. We find that large instruction tuned models like $\mathtt{64B}$ $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ are the easiest to merge. For more details see Section 4.2.
Refer to caption: x5.png

### 4.2 Model merging becomes easier with bigger models

##### Experimental Setup:

In this section, we explore the effect of model size on the held-in performance of merged models. We run experiments using different model sizes, base models, merging methods, and numbers of constituent models. As in the previous experiment, we report the average results over three random seeds and compare the performance of the merged models to that of the task-specific expert models.

##### Findings:

Figure 4 illustrates how increasing base model size impacts merging effectiveness. As model size grows (denoted by colors, $\blacksquare$, $\blacksquare$, $\blacksquare$, $\blacksquare$), merged model performance generally improves. This positive trend is consistent across all base models (different subplots), merging methods (x-axis $\rightarrow$), and numbers of constituent models (subplots). For large instruction-tuned $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models, the merged models perform nearly as well as task-specific expert models denoted by dashed line. These results demonstrate that larger models facilitate merging. This suggests a promising approach for developing adaptive, modular post-training recipes. If the remaining performance gap can be further reduced, model merging could become a cost-effective alternative to multitask training. Our full results across settings are available in the Appendix C.

Figure: Figure 5: Merged models at scale generalize better. We plot the held-out generalization of the merged model for two merging methods. We also include the performance of base model (dashed line) and the multitask baseline (yellow line) which trained on a mixture of held-in tasks. We find that the number of constituent expert models (x-axis, $\rightarrow$) had little effect on zero-shot generalization as shown in the left and center plots. However, increasing model size significantly to $\mathtt{64B}$ improved the merged model’s performance over the base model (right plot). For more details see Section 4.3.
Refer to caption: x6.png

### 4.3 Merged Models at Scale Generalize Better

##### Experimental Setup:

Expert models are created by fine-tuning our base model on specialized tasks, which can lead to a decrease in its generalization capabilities. This raises the question: *How well, if at all, can the merged model generalize to held-out tasks?* Ideally, the merged model should perform at least as well as the base model on these tasks. To explore this, we evaluate the merged model’s performance on unseen tasks across various model sizes, merging methods, and numbers of constituent models. Additionally, we compare our merging approach to a traditional multitask baseline, where a single model is trained on a mixture of all eight held-in task categories. As detailed in Section 3, we normalize the performance of both the merged and multitask model against the base model to assess relative gains or losses in generalization abilities.

##### Findings:

Figure 2 and Figure 5 show the zero-shot generalization performance of the merged model using $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}$, respectively. Overall, we find that: ❶ The merged models outperform their corresponding base models in zero-shot generalization to held-out tasks, as indicated by performance values greater than 1 in most cases; ❷ This improvement is consistent across various model sizes (denoted by subplot), base models (different figures), merging methods (different colors $\blacksquare$, $\blacksquare$), and numbers of constituent models (on x-axis $\rightarrow$), suggesting that merging generally improves generalization; ❸ For weak base models (i.e., $\mathtt{PaLM}\texttt{-}\mathtt{2}$) illustrated in Figure 5, the number of constituent expert models had little effect on zero-shot generalization (Left and Center plots). However, increasing model size significantly improved the merged model’s performance over the base model (Right plot); ❹ In contrast, strong base models ($\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$) show a different trend, zero-shot generalization monotonically improves with the addition of more expert models as shown in Figure 2. We hypothesize this positive correlation arises from reduced model noise through the inclusion of multiple experts, resulting in better generalization; and ❺ Notably, our merged model outperforms the multitask baseline when combining more than $\mathtt{6}$ large instruction-tuned expert models (over $\mathtt{24B}$). This indicates that models developed through merging can generalize even better than those trained on a multitask mixture, offering a promising approach for developing highly capable language models. Our full results on other merging methods and model size are available in Appendix C.

Figure: Figure 6: Bigger model sizes can merge more experts. We merge experts of various sizes created from $\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models and plot the held-in (left) and held-out (right) performance of merged models. While $\mathtt{PaLM}\texttt{-}\mathtt{2}$’s held-in performance degrades with more experts, $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$’s performance stabilizes at a much higher level. Both $\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models consistently improve held-out generalization, particularly at 24B and 64B scales with increasing expert count. For more details see Section 4.4.
Refer to caption: x7.png

### 4.4 Bigger Model Sizes Can Merge More Experts

##### Experimental Setup:

When creating multitask models, datasets for different tasks or domains are typically combined. In contrast, model merging involves developing separate expert models for each task or domain before combining them. Previous work has shown that merging multiple models can reduce the quality of the resulting model (Yadav et al., ; Ilharco et al., ). In this study, we experiment with merging up to $\mathtt{8}$ expert models from various base models, model sizes, and merging methods to assess their impact on successful merges.

##### Findings:

Figure 6 shows the held-in and held-out performance of the merged models using Task Arithmetic as the number of constituent models increases shown on x-axis. Results for other methods can be found in Appendix C. Overall, we observe that: ❶
Unlike merging with $\mathtt{PaLM}\texttt{-}\mathtt{2}$, where held-in performance typically declines with more model merges, merging with stronger zero-shot $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ initially drops slightly in performance before stabilizing as number of constituent models increase. For example, merging eight $\mathtt{8B}$ $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models decreases performance from $\mathtt{0.66}$ to $\mathtt{0.39}$ when increasing the number of experts from $\mathtt{2}$ to $\mathtt{8}$, whereas $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$’s performance only slightly drops from $\mathtt{0.91}$ to $\mathtt{0.86}$; ❷ In the held-out evaluations, the merged experts based on $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models generally outperform the base $\mathtt{PaLM}\texttt{-}\mathtt{2}$ models by a small margin. However, with larger model sizes ($\mathtt{64B}$), the performance improvement increases significantly, achieving about $30$ percentage relative improvement. We attribute this substantial gain to the base $\mathtt{PaLM}\texttt{-}\mathtt{2}$ model’s weak zero-shot performance; and ❸ The merged models based on $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ show improved generalization over $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ across all settings. Additionally, for the $\mathtt{24B}$ and $\mathtt{64B}$ models, we observe a consistent increase in generalization capabilities with the addition of more constituent expert models.

Figure: Figure 7: Different merging methods become similar at scale. We plot the held-in and held-out performances of merged $\mathtt{64B}$ $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models across different merging methods and numbers of constituent models. For more details see Section 4.5.
Refer to caption: x8.png

### 4.5 Merging Methods become similar at Scale

We find that all merging methods exhibit similar performance when merging large instruction-tuned models. This suggests that simpler methods, such as $\mathtt{Averaging}$, can be sufficient for merging powerful large expert models. Figure 7 shows the held-in and held-out performance of the $\mathtt{64B}$ experts derived from $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$. All merging methods yield comparable results on both held-in and held-out tasks for any number of constituent models (shown on x-axis). We hypothesize that as model size increases, expert models are highly over-parameterized due to limited training data. Consequently, the subtle advantages of certain merging techniques – such as highlighting information via task vectors (Ilharco et al., ), resolving interference (Yadav et al., ), or pruning (Yu et al., ) – which benefit smaller models, become less relevant. This indicates a need for more practical and scalable methods to improve merging at scale.

### 4.6 Discussion and Takeaways

In this section, we summarize key insights from our study and provide practical recommendations for model merging practitioners. Overall, we find that: ❶ Creating expert models from the best available base model is always beneficial. The quality of the base model can be gauged by its zero-shot generalization capabilities. We hypothesize that better generalization leads to improved weight disentanglement (Ortiz-Jimenez et al., ) and a flatter loss landscape, enhancing linear mode connectivity and facilitating model merging;
❷ Merged models often underperform compared to task-specific expert models, indicating a potential loss in performance. Despite this, specialized expert models generally outperform general-purpose multitask models (Liu et al., ; Roziere et al., ; Luo et al., ), suggesting that the performance loss may not be significant when compared to multitask models trained on specific tasks; and ❸ Our findings indicate that large-scale merging can accommodate more models and significantly improve generalization, outperforming multitask training when a powerful zero-shot base model is employed. ❹ Surprisingly, we find that when working with large instruction tuned models, different merging method perform very similary. This implies that using simple merging methods like averaging will result in models that are comparable in quality with the models obtained from more advanced merging method. We hope our research inspires further fundamental studies on developing more practical and scalable merging methods.

## 5 Related Work

### 5.1 Loss Landscape and Weight Interpolation

While the loss function of a neural network is generally non-convex, recent work (Draxler et al., ; Freeman & Bruna, ; Garipov et al., ; Jordan et al., ; Gueta et al., ) has demonstrated that the parameter values from different training runs can sometimes be interpolated without increasing the loss (i.e. they are mode-connected).
Many methods (Kuditipudi et al., ; Tatro et al., ; Benton et al., ) have explored finding these low-loss paths between models, focusing on simple (not necessarily linear) interpolations.
For example, Frankle et al. () showed that if a part of the optimization trajectory is shared between two neural networks then they can be interpolated without lowering accuracy. On the other hand, Neyshabur et al. () showed that naively interpolating two neural networks with completely disjoint optimization trajectories can result in a catastrophic drop in their accuracies. Entezari et al. () hypothesized that if we account for the permutation symmetry of neural networks, then all neural networks of a given architecture trained on the same dataset are linear mode connected.
This assumption of the existence of a low-loss ”basin” in parameter space encompassing the models is critical for model merging (Ilharco et al., ).
Ainsworth et al. (); Singh & Jaggi (); Wang et al. (); Jordan et al. (); Peña et al. () therefore used techniques based on finding permutations (Wang et al., ; Ainsworth et al., ) and optimal transport (Singh & Jaggi, ) to better align neural networks trained from scratch so that they can be merged or interpolated without increasing the loss.

### 5.2 Model Merging

Section 2.1 discusses the merging methods that we use for our experiments, however, the popularity of model merging has led to a ever-growing number of methods and applications of model merging (He et al., ; Daheim et al., ; Yadav et al., ; ; ; Matena & Raffel, ; Jin et al., ). Next, we discuss some of these methods which were omitted due to large scale practical considerations. Tangent Task Arithmetic (Ortiz-Jimenez et al., ) fine-tune models in the tangent space for better weight disentanglement when using Task Arithmetic. Akiba et al. () explore using evolutionary algorithms to choose which layers to merge. SLERP (Shoemake, ) and Model Stock (Jang et al., ) consider the geometric properties in weight space where SLERP performs spherical interpolation of model weights while Model Stock approximates a center-close weight based on several FT models, utilizing their backbone as an anchor point. Tang et al. () train a mask that learns which parameters are important for the merged model. Ye et al. () train a gating network to predict a weight that is then used to compute a weighted average of examples during inference. Yadav et al. () provides a comprehensive survey of methods that train a router to route between the different models to merge. Moreover, other applications of model merging include intermediate-task training (Ramé et al., ; Choshen et al., ; ), continual learning (Don-Yehiya et al., ), model alignment (Rame et al., ; ; Ramé et al., ), merging pretrained models Yu et al. (), or merging models in different modalities (Sung et al., ).

## 6 Conclusions

This study conducted a systematic, large-scale empirical investigation of model merging with large language models, addressing the limitations of previous research confined to small-scale models and limited merging scenarios. Through extensive experiments with $\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ models ranging from $\mathtt{1B}$ to $\mathtt{64B}$ parameters, we analyzed the impact of model size, base model quality, merging method, and number of experts on both in-domain and out-of-domain generalization performance.
Our findings demonstrate that model merging effectively combines diverse expert knowledge particularly with increasing model size and with instruction-tuned base models. We found larger models to be consistently easier to merge and can merge more models with less performance degradation. Importantly, model merging led to enhanced generalization capabilities, with large merged models surpassing the performance of multitask models on held-out tasks. These results show that we can develop models that generalise well in a decentralized and modular manner.

## Appendix A Detailed Task Descriptions.

We adopt the experimental setting from the T0 mixture (Sanh et al., ) which contains $\mathtt{8}$ held-in and $\mathtt{4}$ held-out task categories
Specifically, the $\mathtt{8}$ held-in task categories include
Multiple-choice QA (with selected datasets DREAM (Sun et al., ), Cosmos QA (Huang et al., )),
Extractive Qa (Adversarial QA (Adelani et al., ), ROPES (Lin et al., )),
Closed-Book QA (Hotpot QA (Yang et al., ), Wiki QA (Yang et al., )),
Sentiment Analysis (App Reviews , IMDB (Maas et al., )),
Topic Classification (AG News (Zhang et al., ), DBPedia (Lehmann et al., )),
Structure-to-text (Common Gen (Lin et al., ), Wiki Bio (Lebret et al., )),
Summarization (CNN Daily Mail (See et al., ), XSum (Narayan et al., )) and
Paraphrase Identification (MRPC (Dolan & Brockett, ), QQP (Iyer et al., )).
Similary, the $\mathtt{4}$ held-out task categories are
Sentence Completion (with selected dataset COPA (Roemmele et al., ), HellaSwag (Zellers et al., )),
Natural Language Inference (ANLI (Nie et al., ), RTE (Dagan et al., )),
Coreference Resolution (WSC (Levesque et al., ), Winogrande (Levesque et al., )) and
Word Sense Disambiguation (WiC (Pilehvar & Camacho-Collados, )).

## Appendix B Expert Training Details

In our research, we utilized two base models, namely $\mathtt{PaLM}\texttt{-}\mathtt{2}$ and $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ to create specialized expert models. We train the $\mathtt{PaLM}\texttt{-}\mathtt{2}$model for an additional 60000 steps on the Flan-v2 dataset (Longpre et al., ) to obtain the $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ model. We removed the T0 tasks from the flan mixture in order to training experts on them in future. Many of these training jobs were early stopped due to convergence. We used Sharded Adafactor (Shazeer & Stern, ) optimizer along with a cosine decay and a learning rate of 1e-4 for 1B, 24B, and 64B model sizes and 3e-5 for 8B model. We use a dropout value of 0.05. Following Chung et al. (), we used an input length of 2048 and output length of 512. To create expert models we perform full finetuning with the following hyperparameters. For training the experts model, for all model size, we train by default for 2000 steps with a learning rate of 3e-5 and dropout of 0.05. For some task we adjust the number of steps depending upon the convergence. For the purpose of evaluating classification tasks (Raffel et al., ), we perform rank classification. In this method, the model’s log probabilities for all potential label strings are ranked. The model’s prediction is deemed accurate if the choice ranked highest aligns with the correct answer. It should be noted that rank classification evaluation can accommodate both classification tasks and multiple-choice tasks.

## Appendix C Full Result Tables

In this section, we provide the result for the full grid of experiments that we performed. The results contain information about any of the plots that are not provided in the main paper. Table 3 and 4 present the held-in and held-out performance of $\mathtt{PaLM}\texttt{-}\mathtt{2}$ model across all model sizes, base models, merging methods, and the number of experts being merged. Similarly, Table 1 and 2 present the held-in and held-out performance of $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ model.

**Table 1: The table reports the average normalized performance for the held-in tasks when merging experts created from $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ base models.**
| Merging Method ($\downarrow$) | 1B | 8B | 24B | 64B |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| # of Experts ($\rightarrow$) | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 |
| Average | 0.85 | 0.78 | 0.81 | 0.83 | 0.90 | 0.82 | 0.82 | 0.85 | 0.94 | 0.84 | 0.80 | 0.77 | 0.97 | 0.91 | 0.89 | 0.93 |
| Task Arithmetic | 0.91 | 0.82 | 0.84 | 0.86 | 0.95 | 0.86 | 0.85 | 0.88 | 0.96 | 0.90 | 0.91 | 0.92 | 1.00 | 0.91 | 0.90 | 0.93 |
| Dare-TIES | 0.90 | 0.81 | 0.83 | 0.86 | 0.93 | 0.86 | 0.84 | 0.88 | 0.94 | 0.89 | 0.87 | 0.88 | 0.97 | 0.91 | 0.89 | 0.93 |
| TIES | 0.89 | 0.81 | 0.82 | 0.85 | 0.93 | 0.86 | 0.84 | 0.88 | 0.95 | 0.88 | 0.86 | 0.86 | 0.97 | 0.90 | 0.89 | 0.93 |
| Multitask | 0.97 | 0.96 | 0.96 | 0.96 | 0.96 | 0.96 | 0.97 | 0.96 | 0.99 | 0.97 | 0.98 | 0.98 | 0.99 | 0.98 | 0.98 | 0.99 |

**Table 2: The table reports the average normalized performance on the held-out tasks when merging experts created from $\mathtt{PaLM}\texttt{-}\mathtt{2}\texttt{-}\mathtt{IT}$ base models.**
| Merging Method ($\downarrow$) | 1B | 8B | 24B | 64B |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| # of Experts ($\rightarrow$) | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 |
| Average | 0.99 | 1.00 | 1.04 | 1.05 | 1.03 | 1.02 | 1.03 | 1.02 | 1.05 | 1.10 | 1.11 | 1.16 | 1.00 | 1.03 | 1.06 | 1.09 |
| Task Arithmetic | 1.03 | 1.03 | 1.04 | 1.05 | 1.06 | 1.05 | 1.05 | 1.03 | 1.05 | 1.10 | 1.13 | 1.18 | 1.00 | 1.03 | 1.06 | 1.09 |
| Dare-TIES | 1.02 | 1.03 | 1.04 | 1.05 | 1.05 | 1.04 | 1.04 | 1.03 | 1.05 | 1.10 | 1.12 | 1.17 | 1.00 | 1.03 | 1.06 | 1.09 |
| TIES | 1.02 | 1.03 | 1.04 | 1.05 | 1.06 | 1.05 | 1.06 | 1.04 | 1.04 | 1.09 | 1.11 | 1.16 | 1.00 | 1.03 | 1.06 | 1.10 |
| Multitask | 1.11 | 1.11 | 1.11 | 1.11 | 1.12 | 1.12 | 1.12 | 1.12 | 1.18 | 1.18 | 1.18 | 1.18 | 1.05 | 1.05 | 1.05 | 1.05 |

**Table 3: The table reports the average normalized performance on the held-in tasks when merging experts created from $\mathtt{PaLM}\texttt{-}\mathtt{2}$ base models.**
| Merging Method ($\downarrow$) | 1B | 8B | 24B | 64B |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| # of Experts ($\rightarrow$) | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 |
| Average | 0.63 | 0.44 | 0.36 | 0.26 | 0.66 | 0.53 | 0.50 | 0.32 | 0.70 | 0.48 | 0.51 | 0.27 | 0.80 | 0.74 | 0.69 | 0.67 |
| Task Arithmetic | 0.66 | 0.52 | 0.44 | 0.39 | 0.68 | 0.54 | 0.54 | 0.42 | 0.72 | 0.56 | 0.60 | 0.46 | 0.80 | 0.74 | 0.69 | 0.67 |
| Dare-TIES | 0.65 | 0.51 | 0.42 | 0.37 | 0.66 | 0.51 | 0.51 | 0.32 | 0.67 | 0.44 | 0.51 | 0.27 | 0.80 | 0.74 | 0.69 | 0.67 |
| TIES | 0.66 | 0.50 | 0.41 | 0.33 | 0.67 | 0.52 | 0.48 | 0.29 | 0.68 | 0.49 | 0.52 | 0.27 | 0.80 | 0.71 | 0.65 | 0.56 |
| Multitask | 0.88 | 0.88 | 0.88 | 0.87 | 1.06 | 1.04 | 1.04 | 1.06 | 1.25 | 1.15 | 1.11 | 1.20 | 0.97 | 0.96 | 0.96 | 0.96 |

**Table 4: The table reports the average normalized performance on the held-out tasks when merging experts created from $\mathtt{PaLM}\texttt{-}\mathtt{2}$ base models.**
| Merging Method ($\downarrow$) | 1B | 8B | 24B | 64B |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| # of Experts ($\rightarrow$) | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 | 2 | 4 | 6 | 8 |
| Average | 0.98 | 1.00 | 1.02 | 1.04 | 1.01 | 0.97 | 1.02 | 0.98 | 0.95 | 0.85 | 0.93 | 0.83 | 1.28 | 1.24 | 1.29 | 1.25 |
| Task Arithmetic | 1.01 | 1.03 | 1.05 | 1.07 | 1.06 | 1.03 | 1.04 | 1.00 | 1.05 | 1.03 | 1.10 | 1.08 | 1.29 | 1.28 | 1.36 | 1.35 |
| Dare-TIES | 0.99 | 1.01 | 1.04 | 1.05 | 1.02 | 1.00 | 1.05 | 1.01 | 0.97 | 0.89 | 0.99 | 0.90 | 1.28 | 1.24 | 1.28 | 1.24 |
| TIES | 1.05 | 1.06 | 1.03 | 1.04 | 1.07 | 1.04 | 1.02 | 0.99 | 1.01 | 0.93 | 0.98 | 0.90 | 1.31 | 1.22 | 1.24 | 1.15 |
| Multitask | 1.10 | 1.10 | 1.10 | 1.10 | 1.62 | 1.62 | 1.62 | 1.62 | 1.51 | 1.51 | 1.51 | 1.51 | 1.73 | 1.73 | 1.73 | 1.72 |

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Please refer to the Weaknesses section
soundness: 3
strengths: - This paper systematically reveals the impact of different model sizes, quality, quantity, and merging methods on the effectiveness of model merging.
- The figures and tables in this paper are very clear.
- This paper is well organized and clearly written.
summary: This paper systematically analyzes the impact of different model sizes, base model quality, model merging methods, and the number of expert models on the effectiveness of model merging, and draws five key conclusions. In general, this paper is of certain significance to the model merging community.
weaknesses: - Some inconsistencies lack explanation:
    - (1) In Figure 1, why is multi-tasking better than single-tasking in 8B and 24B, but multi-tasking is not better than single-tasking in 1B and 64B? How does this relate to model size?
    - (2) In Figure 5 (PaLM-2-24B, PaLM-2-64B), why is the generalization performance when the number of experts is 8 not as good as when the number of experts is 6? Why does the TIES method perform worse than the pre-trained model when the number of experts increases in PaLM-2-24B?
    - (3) In Figure 6, under PaLM-2-Held-Out, 64B is significantly better than 24B. Why is 64B not as good as 24B under PaLM-2-IT-Held-Out.
    - (4) In Figure 7, why is the performance of merging 8 experts better than merging 4 and 6 experts under the Held-In-64B setting? The greater the number of tasks, shouldn't task conflicts be more serious?
- There is a lack of outlook or suggestions for future directions based on the phenomena observed in this paper.
- Lack of source code and checkpoints. As this is an evaluation paper, the author can consider open-sourcing the resources used in the paper to facilitate further reproduction and research by the model merging community.
- The author can consider adding discussions of the following related work.
    - Model Merging in LLMs, MLLMs, and Beyond: Methods, Theories, Applications and Opportunities. Arxiv, 2024.
    - Fine-tuning large language models for domain adaptation: Exploration of training strategies, scaling, model merging and synergistic capabilities. Arxiv, 2024.
    - FusionBench: A Comprehensive Benchmark of Deep Model Fusion. Arxiv, 2024.
    - Arcee's MergeKit: A Toolkit for Merging Large Language Models. Arxiv, 2024.
- Some minor errors:
    - References are repeated, "Language models are super mario" appears twice, "Extend model merging from fine-tuned" appears three times, and "Model ratatouille" appears twice. The author needs to check carefully whether other references are repeated.
    - Reference year error: Ties-merging was published in NeurIPS 2023 instead of 2024. Similarly, "Task arithmetic in the tangent Space" was also published in NeurIPS 2023 instead of 2024. The author needs to check the year of other references.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: See weakness
soundness: 3
strengths: - This is a comprehensive evaluation, systematically examines multiple factors (model size, base model quality, number of experts, and merging methods) across a large-scale experimental setup, providing robust insights.
summary: This is an empirical study paper that answers questions for model merging. The author explores research questions about model merging. 

- What is the effect of using pretrained vs. instruction-tuned base models for creating expert models for merging?
The instruction-tuned base models outperform the pretrained models in the merging process.
- Does model merging become easier or harder as the model size increases?
Larger models consistently showed better performance in merging, indicating that they are easier to merge effectively.
- How does merging affect zero-shot generalization to held-out (not seen) tasks, and how is this influenced by model size?
Those based on larger and instruction-tuned base models, has improved zero-shot generalization ability. Sometimes surpassing multitask baselines.
- How many expert models can be merged without performance loss, and how does this depend on model size?
Larger models could effectively merge more expert models without significant performance degradation, whereas smaller models experienced performance drops when merging more experts.
weaknesses: - It seems when comparing merging pretrained "experts" and finetuned "experts", after the merging process, the pretrained one is never finetuned. I think it might be unfair to compare between a never finetuned checkpoints and a finetuned checkpoints (althrough it is a merged checkpoint). And thus, it is very natural to predict that merging finetuned "experts" is better than merging pretrained "experts".
- All the tasks (held-in and held-out) are text based. It would be better if involving some vision based tasks.
- The smallest model is 1B. It is small for text models but probably still fairly large for vision models.
- If adding vision tasks, it would be great to check both vision transformer based models and resnet based models.
- Besides, I am also wondering if the way of training the "expert" matters. e.g. Zero-shot contrastive loss for classification vs supervised learning for classification.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. What are the theoretical and practical implications that arise when the merging process extends beyond involving 8 experts? Additionally, does there exist an anticipated performance ceiling in such a context? 
2. It is of great significance to explore the following aspects: Firstly, how could the findings obtained from the current study be extrapolated and applied to other model architectures? Secondly, which specific architectural features might exert an impact on the performance of the merging process? 
3. In Section 4.3, a pertinent query arises regarding the strength of the multitask baseline. Specifically, one might question whether the multitask baseline is overly potent. For example, in the context of 6-expert merging, should the baseline be trained solely on those specific 6 tasks rather than on a combination of all 8 tasks?
soundness: 3
strengths: 1. The objective of this study is to offer profound insights regarding the scalability aspect of model merging, which indeed represents a significant direction within the realm of "scaling".
2. The research presented herein exhibits a comprehensive and meticulous experimental design, which encompasses multiple dimensions such as model sizes, merging methods, and the count of experts. The results are presented in a highly satisfactory manner. Through a sequence of well-conducted experiments, it has been clearly demonstrated that the merged model can effectively harness the diverse expert knowledge. This beneficial effect becomes more pronounced with the increase in model size and when instruction-tuned base models are utilized.
3. The paper is generally well-written and easy to follow.
summary: This paper focused on the model merging issue, exploring various dimensions including model sizes (1B-64B parameters), merging techniques (Averaging, Task Arithmetic, TIES-Merging, Dare-TIES), and the number of expert models (up to 8). The evaluation covers both the tasks the experts were trained on (held-in tasks) and unseen tasks (zero-shot generalization).
  Different with previous studies for small model scales, the study extended the exploration to the effect of scaling model size, as well as the base model quality and number of expert models.
  Key findings include: (1) Merging is more effective when using strong instruction - tuned base models compared to pretrained ones. (2) Larger models are easier to merge. (3) Merging improves generalization capabilities, and with strong base models and increasing numbers of merged experts, the merged model can outperform multitask trained models. (4) Larger models can merge more expert models effectively.
weaknesses: 1. The fact that the study's exclusive concentration lies on PaLM-based models does give rise to legitimate concerns regarding the generalizability of the findings to other architectural frameworks such as GPT, LLaMA, and Qwen.
2. Incomplete theoretical exploration: The paper is heavily empirical, lacking necessary theoretical analysis to explain the observed phenomena. For example，the relationship between weight disentanglement and merging effectiveness.
3. Constraints in Experimental Design:The experimental design of the paper is primarily focused on a narrow range of model sizes (1B to 64B parameters) and a limited number of expert models (up to 8).

Meta-review: Overall, this is an interesting paper but it ultimately needs more extensive empirical analysis as pointed out by several reviewers.

The post-rebuttal ratings are at a borderline but are leaning more towards rejection. In addition, both reviewers who are leaning more towards rejection have not been fully convinced with the authors' rebuttal. 

Given this, the AC believes that this paper is unfortunately below the acceptance bar at ICLR. The authors are encouraged to revise the paper with more extensive experiments and resubmit to a future venue. The AC believes that with a stronger set of experiments, the paper will have much better ratings in the next round.

Decision: Reject