Dataless Knowledge Fusion by Merging Weights of Language Models
Authors: Xisen Jin
Xiang Ren
Daniel Preotiuc-Pietro
Pengxiang Cheng
Venue: ICLR 2023 poster (2023)
Keywords: model merging
weight merging

Abstract: Fine-tuning pre-trained language models has become the prevalent paradigm for building downstream NLP models. Oftentimes fine-tuned models are readily available but their training data is not, due to data privacy or intellectual property concerns. This creates a barrier to fusing knowledge across individual models to yield a better single model. In this paper, we study the problem of merging individual models built on different training data sets to obtain a single model that performs well both across all data set domains and can generalize on out-of-domain data. We propose a data-less knowledge fusion method that merges models in their parameter space, guided by weights that minimize prediction differences between the merged model and the individual models. Over a battery of evaluation settings, we show that the proposed method significantly outperforms baselines such as Fisher-weighted averaging or model ensembling. Further, we find that our method is a promising alternative to multi-task learning that can preserve or sometimes improve over the individual models without access to the training data. Finally, model merging is more efficient than training a multi-task model, thus making it applicable to a wider set of scenarios.

Published as a conference paper at ICLR 2023
DATALESS KNOWLEDGE FUSION BY MERGING WEIGHTS OF LANGUAGE MODELS
Xisen Jin Xiang Rens, Daniel Preotiuc-Pietro Pengxiang Cheng?
SUniversity of Southern California (xisenjin, xiangren) edu (dpreotuupie, pcheng136 34 www.oeeeeoooo..o.oeoooo.eo
fBloomberg
ABSTRACT
Fine-tuning pre-trained language models has become the prevalent paradigm for building downstream NLP models. Oftentimes fine-tuned models are readily available but their training data is not, due to data privacy or intellectual property concerns. This creates barrier to fusing knowledge across individual models to yield a better single model. In this paper, we study the problem of merging individual models built different training data sets to obtain a single model that performs well both across all data set domains and can generalize on out-of- domain data. We propose a dataless knowledge fusion method that merges models in their parameter space, guided by weights that minimize prediction differences between the merged model and the individual models. Over battery of evalua- tion settings, we show that the proposed method significantly outperforms base- lines such Fisher-weightee that our method is a promising alternative to multi-task learning that can preserve or sometimes improve over the individual models without access the training data. Finally, model merging is more efficient than training a multi-task model, thus making applicable wider set of scenarios
averaging or model ensembling. Further, we find
INTRODUCTION
The dominant paradigm for solving NLP tasks ranging from classification to sequence tagging in- volves linettunig&& a pretrained language model (PLM) using task- labeled data (Devlin al.] 2019 He et al. 22221) This results in specialized models that are explicitly trained to run inference over single domain and task. Multi-task learning has shown that leveraging information across do- mains tasks can be beneficial if the data sets, data set size and algorithms are well selected (Phang ctt al. 20188] Pruksachatkun et al. 2020: Poth et al. 2021 Weller et al. 2022). Combining knowl- edge of multiple data sets in single model can lead to better overall performance
in-domain data (Poth et al. )0 can better generalize on out-of-domain data (Wang et al. 2020b) and results in model that more practical and parameter efficient than maintaining specialized models.
However, the multi-task learning setup suffers from two practical limitations. First, the training process requires access the original labeled data, which may not be realistic as annotated data may be private to the agent fine-tuning the model which can happen in order to ensure data or annotation privacy or guard intellectual property to annotations. Second, because a significant amount of data or task combinations are not beneficial to performance (Poth et al.) 2021). building a single model requires training on all data combinations identify the optimal one, which can be prohibitive especially if there are many available source data sets or models.
Model merging is defined as combining multiple models into a single one in parameter space with- out access to data (Matena & Raffel, 202T). This technique provides alternative to building single model while satisfying data privacy constraints. Weight merging algorithms usually also have a closed-form solution, making them very efficient as no retraining is necessary, thus enabling us- age even when a large number of data sets or model combinations are available. Merging can be considered an alternative to model ensembling (Opitz & Maclin 1999 Rokach 2010), where the
TThe code is available https:///gitiiii wtt.:/o//owccc/////ooooccoocc//e less model -eerging

---

Published as a conference paper at ICLR 2023
Donaiin
Dn
Dona in N
Multi-Task
Ensembling
Federated Learning
Model. Merging
Learning
By
D.
Bata
Better La-doeoia performance acress multipte
Dala b,
Models
Noste:
Model
Mudel
Data
Outputs
Glibha Model
0g
Pior ginn Function
Aggregate
Herged
Model
Doma
Dona
1o1 Task Mocel
Predict
D
Better fdd-aann gene Lization
No data No retraining Single Round
Datw by
Data
Acceis to data
data
Private Model Mulriple rounds
Single Model
High cxmoryy cost
Figure 1: Diagram containing the problem formation for model merging and its comparison to other setups including multi-task learning, model ensembling and federated learning. Models f1..N trained by individuals organizations are released to the user (optionally with some statistics) but the training data DI...v is kept private.
outputs individual models are combined to produce the final prediction. Model merging algo- rithms are a key step in federated learning (McMahan et al.] [017)] Lin et al. 2022), where multiple agents train their own model using private data and share only model updates with other models. However, in federated learning, model merging happens in multiple rounds of updates, after which the merged model is broadcast to all agents before the next round of training with private data. This dataless model merging is thus an extreme case of federated learning, where single round of synchronization is admissible. Figure |
provides an overview of the various related setups.
We thus aim to use model merging to build a single model that can be used for inference on multiple domains or tasks and can generalize to new domains, in line with Wang et al. (2020b). In contrast, simple averaging of weights for model merging was used by existing works such as WWotsman al. (2022) to improve the performance of specific model, where weight averaging was done over models fine-tuned using the same data set with different hyperparameters. Separately, |Matena & Raffel (202T) focus improving performance over single target task by leveraging models trained on other donor tasks by merging models using weighte averaging.
This paper focuses merging fine-tuned models that originate from pre-trained language models with the same architecture and pretrained weights. We introduce a novel model merging method named Regression Mean (RegMean), which is computationally efficient and extendable merg- ing any number of models. 'he method is inspired by the optimal solution for linear models that minimizes 82 distance between merged and individual models and has closed form solution. We evaluate model merging algorithms in setups that range in complexity and type of fused knowledge. The experimental results across multiple model types (e.g. RoBERTa, T5, DeBERTa) show that our proposed method consistently and significantly outperforms other model merging and ensem- bling baselines and achieves higher generalization performance than the best individual models on out-of-domain data sets across several data collections.
Our contributions are three-fold: (1) novel model merging algorithm (Regression Mean); (2) an evaluation protocol for model merging algorithms that tests both in in-domain and out-of out-of-domain generalization ability; (3) analysis computation and parameter efficiency across setups.
DATALESS MODEL MERGING FOR KNOWLEDGE FUSION
We consider the problem formulation that there are two main roles in the framework: (1) the agents (e.g., individuals or organizations) that train and release models; (2) the developers who aim to build single model by fusing knowledge of multiple available models. Each agent E {1..N} fine-tunes a language model (LM) fi of pre- pre-trained weights QLM over their private labeled dataset D, (X,, Y;) to obtain fine-tuned model weights 0,, where X; R.N.* are inputs, Y; E Ni, are labels and N; the number of annotated examples. The agents keep the labeled data set D₃ private. In addition to the fine-tune model weights f((:; 0.), the agents can also optionally disseminate certain statistics 5,, as long as these do not leak information about the labeled data set D;.
In turn, the developers use the fine-tuned model weights fi(:; 0,) and statistics S, as inputs merging function g. The merging function is applied to a subset of fine tuned models K. C [1..N} (of size K IKC) to obtain parameters 0.c. of a merged model fMe, where 0Ms =g(0k, Sx). In general, we expect the function g to be computationally efficient and to produce 8 with a closed-form formulation.
2

---

Published as a conference paper at ICLR 2023
Simple Le
Fisher
Linear
W2
W2
/2
W
P
W2
F3
Attention
Y W X
RegMean
Linear
Lornar
Metrics: Optimal Wyr
x
x
W;
x3xx
W2
W3'x
Figure 2: Comparison between Simple, Fisher, and RegMean for merging transformer-based language models. Fisher and RegMean require Fisher Information matrix or inner product matrices of layer inputs, but neither of them requires training data. For linear models, RegMean produces optimal weights that minimize 8 -ddistance individual model predictions on the corresponding training sets.
REGRESSION MEAN FOR MODEL MERGING
The key role in the model merging setup is played by the merging function g. We start with briefly introducing existing techniques for model merging. followed by the basic intuition for our proposed method, which we then extend to transformer-basee is that the model architecture for all models fs is the same, allowing for element wiie operations needed and resulting in a merged model fMx of the same architecture and size as any individual model. We also assume models are fine-tuned from the same pretrained LM checkpoint. The study of methods that relax this constraint are outside the scope of this paper and are left for future work.
language models. The underlying assumption
3.1 PRELIMINARIES
Simple Averaging (Simple) computes the merged weights as the element-wiss arithmetic mean of the weights of other models: 0л 1/K Σ 0,. This technique was proved to be effective when merging model weights that are already similar or in a similar space, such checkpoints generated after each epoch in a training process (Wortsman et al. 2022). We expect simple averaging to under-perform when model weights live in different space and are substantially different each other, such as when merging models trained with different data or when performing merging for models fine-tuned after the entire training process, as opposed to synchronizing models after rounds as in the federated learning setup.
Fisher- Weighted Averaging (Fisher) aims address the limitation of simple averaging of weights with potentially different importance. The method relies on computing per-weight importance F; for each individual model and reweighting the weights with this importance factor during merging as follows: 0MK = Σ: P.O./ Deek F.. Here, F; the diagonal of the Fisher Information matrix, where F. Eg By.ppuuu Vo, (log po, (y) ())2r)))² Intuitively, F, measures averaged gradient norm of parameters w.r.t. log likelihood of each label, where parameters with high average norms are considered important.
3.2 MERGING LINEAR MODELS
Next, we recast the problem of model merging as a straightforward optimization problem. We start by inferring the optimal solution of merging two linear regression models trained on different data distributions and analyze its relationship to Simple averaging.
Consider two linear models fi WT x and fz(x) WT x, where x E R" and Wi W2 Rmxn that are trained on two different annotated datasets (X v1)), (X2, U2) where X, E R Ni and X2 E N22 Each row in X, corresponds to a training example, Our goal to obtain a single merged model (ar( = W = with outputs similar to fi on Xi and f2 on X2. With e distance as the metric, the optimization problem can be formulated as:
min
|| X, WT |1 + X2 WT X2112.
Eq. 1 describes a linear regression problem, where the inputs are [X1; X2] (row concatenation of X1 and X2) and the targets are [W7 X1; W X2), which has closed form solution Wy (XF + X (x7 X, W + X W,). The algorithm extends to merging K models W,, E K. with little modifications to the optimization problem in Eq.
AeA:
EE
WM = >
x x₂)
> (X
(2)
3

---

We illustrate RegMean in Figure 2 and Published as a conference paper at ICLR 2023
Regression Mean (RegMean). To summarize, merge linear model fa with other models, we pre-compute the inner product matrices of training data X/";; we do not recompute X X, when merging with different models. The merger retrieves the weights and inner product matrices of inputs of individual models and compute the weights in Eq.
We refer Eq.
Interpretation. RegMean can be also interpreted as reweighting and linearly combing rows in weight matrices, where the diagonal items of X X; mainly reweight the rows, while non-diagonal items linearly combine them. In an extreme case when x/"x; X; is diagonal, RegMean simply reweights the rows in W, by the importance of neurons. Besides, when all X? X; (or all X;) are the EE W,.
same, Eq. transforms into simple averaging, i.e., WM 1/KE,
3.3 REGMEAN FOR TRANSFORMER LANGUAGE MODELS
Transformer models consist of feed forward layers and attention heads where linear layers are im- portant components. For all linear layers, we independently apply RegMean. We record x x(()) of each linear layer f()), where x() is the input features of the linear layer. The other types of weights, such as embeddings and bias terms, that represent a small portion of the overall parameter set are merged using simple averaging.
Reducing Non-Diagonal Items of Inner Product Matrices. We empirically find that directly applying 2q.2for merging yields degenerated models case of some pre-trained LM architectures. We therefore decrease the non-diagonal items of the inner product matrices by multiplying them with a scalar a (set as 0.9 most of the times). This also corresponds to adding a regularization term in the optimization objective in Eq. that penalizes the Euclidean distance between the merged weights W M and individual model weights WI..K.
We include formal derivation and proof in Appendix A summarize the complete MegMean method in Algorithm
Algorithm 1: RegMean for Transformer Language Models
Data: Individual Models fi..k. Number of linear layers J. inner product matrices C
x for XGT
all linear layers j and models 1 < < K, Scaling factor of non-diagonal items
Result: Merged model fMr for j in 1, 2,.., do W(5) W ..., W +
Reduce non-diagonal items of inner product matrices G as (69) +- af + (1 ()diag(((()) w
(iE -(:))~²X Die((E)))) (C())( and set the weight as W in fM
end
Average weights as WM DiEk W; for weights other than linear layer weights in f's
3.4 PROPERTIES OF REGMEAN
Computational Efficiency. Inner product matrices of all linear layer inputs can be computed within one single forward pass over training data after individual models are trained. It is more efficient than computing Fisher Information matrices, which requires an additional backward pass to compute gradients.
Memory Overhead. The memory overhead of inner product matrices is E/= dz. where is the number linear layers the model and d, is the input dimension of linear layers. For transformer models, this overhead is comparable the number of parameters and Fisher Information matrices.
Data Privacy. It should be noted that RegMean never requires training data X, when merging; instead, it only requires low-dimensional inner product matrices. The agents that release the models can share the matrices without sharing the private training data and their labels.
EXPERIMENTAL SETUP
4.1 EVALUATION SETTINGS
We expect two major benefits of merging models for the developer. First, by combing knowledge of individual models fi..N (or subset IC of them, fx) trained DI.NN we expect the resulting
4

---

Published as a conference paper at ICLR 2023
merged model fas to achieve competitive test performance across all datasets DI..N. This model is useful for example when the test distribution is a mixture of D1..N. w. In addition, a single model has the additional advantage of being able to run inference across multiple domains when the user of the model provides data from one of the domains, but is not aware of the domain label (Wang et al.) 20206). In our case, D can represent different non-i.i.d partitions of the same dataset, different domains for the same task or different tasks altogether.
Second, we expect the merged model to achieve higher out-of-domain (OOD) generalization ability. Formally, we evaluate the performance of the merged model J'M over the out-of-domain test sets Df.NN, where the data distributions are different from any of DI..N-
Datasets. We use the GLUE datasets (Wang et al. 2018) for studying merging models trained for non-i.idd partitions and merging models trained for different tasks. We use emotion classification and named entity recognition (NER) as base tasks for studying merging models trained on different domains of the same task. For emotion classification, we use the collection of preprocessed datasets from (Oberländer & Klinger] (0188) We choose 5 high-resource datasets for training individual models and low-resources datasets for evaluation of out-of-domain generalization ability. For NER tasks, we use 6 domains in OntoNotes (Hovy et al., 2006) for training individual models, and use CoNLL (Sang & De Meulder 2003) and Twitter NER (Rijhwani & Preotiuc- Pietro 2020) to measure out-of-domain generalization performance. We include details of datasets in Apppendix B
Metries. In the case of merging models trained on non-i.id. partitions of the same dataset, we eval- uate the merged models over single test set with joint distribution of all partitions. For merging models trained on different domains or tasks, we measure the performance over all single domains or tasks incorporated into merging and take their macro-average. For out-of-domain evaluation, we similarly take macro-average over the performance over the out-of-domain test sets.
4.2
COMPARED METHODS
Model Merging. For model merging algorithms, we compare the performance of RegMean with the previously introduced methods of simple averaging (Simple) (Wortsman al. 2022) and Fisher- weighted averaging (Fisher) (Matena & Raffel (021).
Model Ensembling. Model ensembling represents alternative model merging when access to the original data is not available. We thus build an ensemble model (Ensemble) by obtaining all logits from the individual model predictions and averaging them before doing an argmax.
Individual Models. To provide context into the benefits of merging, we report the performance of individual models involved in merging. We thus report: (1) the average performance of all individual models (Avg. fi..N); (2) the performance of the best single individual model (Best. fi..N), as determined by using the validation set; (3) the performance of the individual models corresponding to the training data set for each test set (Domain-Speciffe
Multi-task Learning (MTL). We also consider MTL which trains a single model over the joint training data sets DI..N. We note that the multi-task method should represent an upper-bound for model merging, as multi-task learning has access to the original labeled data which can leverage to train better model when compared to dataless approaches such as model merging. Depending on the data sets, the task can be the same (e.g., emotion prediction) or different (e.g., GLUE tasks).
4.3 EXPERIMENT DETAILS
Pre-trained Models. We initialize all models fa using the same architecture and by using the same pre-trained model weights 6LM. We experiment with multiple pre-trained models as starting points for merging. We experiment with both encoder-only models including the classic RoBERTa- base (Liu et al. 2019) and -fate-of-the-art models like DeBraRTa-largevv (He et al. 2021 and with encoder-decoder models represented by T5-base-vi.1 (Raffel al.. 2020). We note that T5-base- v1.1 is not applicable to sequence labelling tasks represented by NER experiments. Further training details are in Appendix B
Model Initialization. It has been shown that model merging is more successful when individual models share the same weight initialization (McMahan et al.] 2017). In this paper, we focus on merging fine-tuned language models of the same architectures and initialized from the same pre- trained model weights fIM before fine-tuning. For new classification heads, we present the results of both shared initialization (Same Head Init, SH) and different initialization (Diff Head Init,
5

---

Published as a conference paper at ICLR 2023
-20
-10
-25
Drop %
Drop %
Drop
-50
25
Simple trsher
RagMeen
Simple Fisher
RegMecan
200
sumpl
Fishet
RegMtan
Simple
Fisher
RegMean
-20
somple
Fisher
RegMeen
(a) RoBERTa- base,
(b) TS-buse
DeBERTa large, (c) DeBERTa-lage, (d) RoBERTss buse,
Emotion
Emotion
Emotion
NER
NER
Figure 3: Relative performance drop (%) of pairwise merged models compared the domain-specifie models.
Positive values indicate performance improvement after merging. The boxplots summarize results over (C or 15 (C2) combinations of 5 or 6 domain-specific models in Emotion and NER. The triangles denote the mean. Note that y-axes are not in the same scale.
DH), as our proposed method is amenable to both. This does not apply to T5 where we fine-tune the pretrained LM head for prediction.
Hyperparameters. We set the non-diagonal multiplier in RegMean to 0.9, with the exception of
T5-base models, where it is 0.1. We compute inner product matrices with at most 1, 000 training batches. Sensitivity analysis of hyperparameters is presented in Section 5.3 and Appendix C
5 RESULTS
The main goal of our experiments is to benchmark the performance of different dataless model merging methods and compare these with individual model performance before merging. addi- tion, we aim situate these methods in context of other methods which represent upper bounds due to having access to more information (i.e. data for fine-tuning) than model merging.
Our experiments examine knowledge fusion from perspectives: (1) in-domain performance over test data sets similar to those over which individual models are trained, and (2) out-of-domain generalization performance over data sets from held-out domains or tasks. We study performance dynamics in range of scenarios ranging in difficulty. First, we study a simple scenario where merging is performed on models are trained on non-i.i.d. partitions of the same data set. Next, we study merging of models trained on different domains of the same task and lastly merging models trained on different tasks.
5.1 MODEL MERGING FOR FUSING IN-DOMAIN KNOWLEDGE
Merging Models Trained on Non-i.i.d. Parti- tions. We start with setup in which we merge models trained on non-i.i.d partitions of the same data set, which is simulated using syn- thetic data splits benchmark. For each task, we split training data into two partitions with 1,000 training examples with different label distributions (details in Ap- pendix B. We then fine-tune 8 pairs of individ- ual models over the two partitions and merge each pair of the models. The merged models are evaluated on the official validation sets (i.e. with a joint distribution of both partitions). In Table I we find that model merging consistently im- proves over average performance of individual models across the 8 tasks. This verifies that weight merging allows combining knowledge from individual models and can lead to a more powerful single model. We further note that RegMean outperforms simple averaging and is similar in perfor- mance to wishhteweighted averaging. This is a proof-of-concept that model merging and RegMean work in simple scenario.
Avg. fi.x
Simple
Fisher
RegMean
SST-2 MRPC STS-B
86.80
89.98
90.00
90.23
79.34
80.44
80.39
81.96
87.50
87.86
88.15
88.20
the 8 tasks in the GLUE
8-task Avg.
71.76
74.22
75.25
75.27
Table 1: Merging models trained on Non-i.i.d. parti- tions of GLUE tasks. We compare the performance of the merged models (Simple, Fisher, RegMcan) and the average performance of each pair of individual models (Avg. f1..N) the joint validation
Merging Models Trained on Different Domains. We next shift to a more challenging setup where individual models trained data from different domains of the same task.
Painwise Merging. We start by merging pairs of models trained on different domains. For emo- tion classification and NER, have 10 (C3) and 15 (Cz) combinations of domain-specific mod-

---

Published as a conference paper at ICLR 2023
Emotion
NER
Model ( (>))
RoBERTi-buse
DeBERTa-lange
T5-base
RoBERTa-hase
DaBeRTa-large
Method ())
Same / Diff Head Init.
Same / Diff' Head Init.
Avg. fi.N
18.91 23.98
32.16
27.56 33.86
77.02
76.69
Best. f
34.19
88.46
84.
Ensemble
27.21 / 26.82
38.89
28.93 28.44
85.45
86.40
Simple
21.31 0.00
39.52
2.96 0.00
81.63
55.37 33.
Fisher
28.27
39.28
10.88 20.16
76.75
RegMeun
38.73 32.56
40.32
38.31 18.83
85.68
85.51
Domain-Speeific
51.02
49.38
52.53
88.61
88.31
MTL
47.75
49.06
51.52
90.41
90.12
Table 2: In-domain performance when merging all 5 emotion classification models or NER models. Sim- ple, Fisher and RegMean are the model merging algorithms comparison. Bold numbers indicate the best performance across different model merging algorithms.
els respectively. The boxplots in Fig. summarize the relative performance drop compared domain-specific models NCV-IJ Ei=1 1...., D.) MiSi, D.)I/D/((CC... D:), where M(S, D) denotes the metric score obtained by evaluating f on the test set of D. The per- formance drop is reasonable as the merged model set is a mixture of all domains, the merged model usually outperforms single individual models, we will in the next paragraph. We clear differences between model merging algorithms, where RegMean performs the best. On RoBERTa-bon and DeBERTa-large, RegMean reduces per- formance drop on Emotion from 55% to 12% and 85% 15% compared simple average.
inference both domains; when the test
Merging All Domain-Specift Models. We further exper- iment in setup of merging all or domain-specific models on Emotion Classification and NER. Table 2 summarizes the results. Results show that merging all models is challenging setup. The large differences be- tween the average and the best performance of individual models (Avg. f1.NN and Best f1..N) indicate the perfor- mance of individual models have a high variance. As a result, model ensembling suffers from poor individual models: the improvements are mostly marginal com- Emo-
Drop
20
Drop
-40
Simple Fisher
RegMean
Simple
Fisher
RegMean
(a) DistilBERT-be base
(b) RoBERTa-base
pared to Best fI.N, while on DeBERTa-large tion, the performance is actually lower. In contrast, MTL improves performance significantly over Best fI.NN and achieves performance similar to or better than domain- specific models, which implies single model is capable of encoding knowledge of all domains in our setup.
Figure 4: Relative performance drop (%) of merged models compared to ssscispccffic models in our pairwise model merging exper- iments over GLUE.
We then compare three different merging algorithms. RegMean achieves the best in-domain per- formance on both Emotion and NER tasks, except for DeBERTa-large on Emotion, where Fisher performs slightly better. Simple averaging performs poorly (except for T5), especially on RoBERTa- base and DeBERTa-large in the emotion tasks. We note that Fisher clearly under-performs RegMean in our previous pairwise merging experiments; Fisher-weighted averaging may actually produce merged model that is very similar to one of the individual model. RegMean also outperforms sembling in all but one of the five scenarios.
Reg.Maan also clearly outperforms Best fi.N RoBERTa and model merging with RegMean useful for performance purposes, in addition to the practical conve- nience of deploying and maintaining single model for multiple domains.
Emotion, which makes
Merging Models Trained on Different Tasks, We also experiment with merging models trained on different tasks using DRR--bBETT- and RoBERTa-base. We train individual models with full training data of 8 GLUE tasks. We do not merge task-specific classification heads as these can have different dimensions depending on the task and output space. We summarize the results in Figure We again see similar pattern when comparing model merging techniques with RegMean clearly improving over Simple averaging and wisher-weighted averaging.
5.2 MODEL MERGING FOR OUT-OF-DoMAE GENERALIZATION
7

---

Published as a conference paper at ICLR 2023
Emotion-Heldout
NER-CoNLL
NER-Twitter
Model (-)
RoBERTa-base
T5
DcBERTa-larg Same Diff Head Init.
RoBERTa
DeBERTa
RoBERTa
DeBERTa
Method ())
Same / Diff Head Init.
base
buse
large
base
large
Avg. f
21.71
30.30
20.76
67.91
69.76
44.50
41.10
Best. J
30,06
37.54
31.10 12.55 / 10:65
80.24
83,33
58.40
52.48
Ensemble
11.92/ 10.90
28.10
85.45
80.58
48.43
48,59
Simple
11.17 / 0.00
38.77
0.81 / 0.00
73.92
54,95
48.07
29.93
Fisher
20.67 18.76
37,84
5,80 32.04
68.68
42.13
45.81
26.05
RegMeun
22.75 15.53
39,58
16.40 5,002
78.27
80.43
50.70
46,76
MTL
28.29
37.71
30.94
78.53
80.60
33.21
43.55
Table 3: Out-of-domain performance when merging all 5 emotion classification models 6 NER models. Bold numbers indicate the best performance across different model merging algorithms.
Out-of-Domain Generalization when Merging all Domain-Specific Models. Table Bl summarizes OOD generalization performance when merging all domain- specific models. We see similar pattern in OOD gen- eralization performance where RegMean in general per- forms the best across all model merging algorithms. The performance is lower than Fisher only on RoBERTa-base and DeBERTa-large with different head initialization. We also see that RegMean outperforms model ensembling in most cases, which comparable in the amount of in- formation it can use. Further, on the emotion classifica- tion data sets, it is notable that RegMean achieves higher OOD performance than the best fi..N T5-base. We also found that knowledge fusion itself can negatively im- pact performance when there poor individual models: on NER, all merging algorithms and even MTL does not achieve better OOD performance on CoNLL and Twitter than picking the Best fI..N, as previously indicated in Wang et al. 2020b
25
T5-base
DeBERTa-large
0.2
0.6
0.8
(a) Merging two mudels
50
In-Domain
000
0
0.6
0.8
(b) Merging all models, TS-base
Figure 5: Performance of RegMean with different values Emotion Classifica- tion. * denotes for Simple Average.
Incrementally Merging a Subset of Models. In scenario where OOD performance of each indi- vidual model is known (e-g., when the validation sets of the OOD data sets are provided), we can mitigate the impact of having poor individual models by merging only subset K. C [1..N} of models. We apply a similar technique as Wortsman et al. (2022); Ramé et al. (2022) which greedily identifies new individual models to merge. We use their OOD performance on the validation sets to incrementally add models and plot the results in Figure 6 In general, merging only a subset of models better than merging all models, e.g., on GoBERTa-base with the same head initialization, RegMMan outperforms Best fi.N by merging only two models.
5.3 DISCUSSION
Pre-trained Model Impact in Merging. Our results also show that the underlying pre-trained model is important factor that affects the performance of merged models. Overall, merging T5-base models is successful even with simple averaging, while DeBERTa-large is hard to merge, which hints to an interaction between merge-ability and pre-training objective. We believe a more comprehensive study of such factors is an interesting direction of future work.
Impact of Scaling Non-Diagonal Values in Inner Product Matrices. We noticed when a 1.0 (i.e,, no scaling), RegMean yields degenerated performance on T5-base and DeBERTa when merging two models, while slightly decreasing to 0.9 eliminates the issue. In the other extreme case when = 0. the inner product matrices become diagonal and RegMean simply reweigh rows of weight matrices, making the method similar to Simple Average. We plot the pairwise merging performance of RegMean with 0 < a < 1 in Figure 5a for T5-base and DeBERTa-large as well as the performance of merging multiple T5 models in (5 We observe that the performance of RegMean is mostly stable between T5-base models, both in-domain and OOD performs reaches maximum at a = 0.1 and slowly drops with increase in a, whereas OOD performance suffers slightly larger drop.
0.1 and 0.9, but suddenly drops at 1.0. When merging multiple
Limitations. We note that the requirement of inner product matrices in RegMean (and Fisher Infor- mation in weihhe-weighted averaging) can be limitation. To merge existing models released online
8

---

Published as a conference paper at ICLR 2023
40
80
55
38
75-
50
ResPion
4 Merged Model
2
Merged Model
Merged Model
Merged Model
(a) RoBERTi-base (SH) EmmttionHHeele
(b) TS-base Emotion Heldout
(c) RoBERTa-base (DH) CONLL
(d) DeBERTa-large (DH)
Twilter
Figure 6: Examples of improved out-of-domain generalization performance when incrementally merging subset of individual models in the order of their OOD performance compared merging all models. The main comparison against the best individual model fi..N (shown in the dashed line).
without these statisties, few training examples (see Appendix [oror the sensitivity the number of training examples) are needed to compute them. Besides, there is risk that inner product matrices may reveal information about training data. Quantitatively measuring information leakage in these statistics should be good direction of research in the area of privacy.
6 RELATED WORK
Model Merging and Weight Averaging. Past research studied model merging for different end goals. Izmailov et al. 20188: Gupta et al.] (2020); Wortsman et al. (2022) aim to improve model performance by averaging weights across different checkpoints different runs. Cha et al. (2021); Arpit et al. (202)) : Ramé et al. (2022) study domainn-enerrliizatoon by averaging weights of models trained over the same datasets with different configurations. |Maena & Raffel (2021) study merging using Fisher-weighter averaging with the aim of improving performance on a single target task by leveraging other 'donor' tasks. Choshen et al. (2022) show fusing fine-tuned models with simple weight-averaging creates a better starting point of fine-tuning for new tasks. Weight averaging was also used by Li et al.] (2022) for building language models with multi-domain capabilities where new domain "experts" are initialized using weight averaging from the existing experts. WWan et al. (022)) use weight averaging to fuse knowledge learned when training multiple adapters with the aim of obtaining better few-shot capabilities and increased model robustness. Merging updates of private models is a crucial intermediate step in federated learning (McMahan et al. 2017; Li et al. 2019). However, key in federated learning algorithms is that the joint model is iteratively updated in multiple rounds, which is not allowed for model merging. The success of simple arithmetic mean for model merging has been explained from the perspective of loss landscapes and linear mode connectivity (Frankle et al., 20200] Neyshabur et al., [0200] Draxler et al.] 2018 Ainsworth et al., 2022). Further, improved merging algorithms aim to match permutations between the weights of different models (Singh & Jaggil 2020; Nguyen et al. [021] Ainsworth et al., 2022; Wang et al.,
2020a), which complementary line of effort to our work. We experiment with permutation
matching algorithms and present our analysis in Appendix D
Knowledge Fusing via Distillation. Recent work has used the knowledge distillation framework to fuse the capabilities of multiple teacher models by distilling them into smaller student model at fine-tuning or pre-training stage (Khanuja et al. 202T), albeit requiring full access to data for distil- lation. Dataless distillation, although for computer vision architectures and not using Transformer- based approaches, was attempted (Lopes et al. 2017 Nayak et al. (019). These have the addi- tional disadvantage of not having closed form solution and are thus not computationally efficient.
7 CONCLUSIONS AND FUTURE WORK
This paper studied the problem of fusing knowledge of multiple fine-tuned language models by model merging without access to training data. We proposed a new method inspired by linear models named Regression Mean (RegMean). We introduced series of experimental setups in which we demonstrated that our method outperforms other alternatives to dataless merging or ensembling. Further, non-i.i.d. and out-of-domain experiments, we showed that model merging can outperform individually trained models. Merged models are also very practical, especially when compared to hosting multiple models, as the merging algorithm is very efficient, adds a minimal number of additional parameters and has similar inference speed to any individual model.
The implications of model merging are wide ranging from efficient intermediary task selection to improve performance combining models trained with private data in federated learning setup. Future work can focus on merging models with different initialization or architectures, merging models sequentially at scale merging pre-trained models before the fine-tuning stage.

---

Published as a conference paper at ICLR 2023
ACKNOWLEDGMENTS
Xisen Jin is supported by Bloomberg Data Science Ph.D. Fellowship.
REFERENCES
Samuel Ainsworth, Jonathan Hayase, and Siddhartha Srinivasa. Git re-basin: Merging models modulo permutation symmetries. arXiv preprini arXiv:2209.0488 2022.
Cecilia Ovesdotter Alm, Dan Roth, and Richard Sproat. Emotions from text: machine learning for text-based emotion prediction. In Proceedings of human language technology conference and conference on empirical methods in natural language processing, pp. 579-586, 2005.
Devansh Arpit, Huan Wang, Yingbo Zhou, and Caiming Xiong. Ensemble of averages: Im- proving model selection and boosting performance in domain generalization. arXiv preprint arXiv:21 10832. 2021.
Daniel Cer, Mona Diab, Eneko Agirre, Inigo Lopez-Gazpio, and Lucia Specia. Semeval-2017 task and cross-linge moos-llnggua focused evaluation. arXiv preprint
1: Semantic textual 2017.
Junbum Cha, Sanghyuk Chun, Kyungjae Lee, Han-Cheol Cho, Seunghyun Park, Yunsung Lee, and Sungrae Park. Swad: Domain generalization by seeking flat minima. Advances in Neural Infor- mation Processing Systems, 34:22405-22415 2021.
Leshem Choshen, Elad Venezian, Noam Slonim, and Yoav Katz. Fusing finetuned models for better pretraining, ArXiv, abs/2204.03044, 2022.
Jacob Devlin, Ming-War Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguisties: Human Language Technologies, Volume I (Long and Short Papers), pp. 4171-4186, Minneapolis, Minnesota, June 2019.
Bill Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In Third International Workshop Paraphrasing (IWP2005), 2005.
Felix Draxler, Kambis Veschgini, Manfred Salmhofer, and Fred Hamprecht. Essentially no barriers in neural network energy landscape. In International conference on machine learning, pp. 1309- 1318. PMLR, 2018.
Jonathan Frankle, Gintare Karolina Dziugaite, Daniel Roy, and Michael Carbin. Linear mode con- nectivity and the lottery ticket hypothesis. In International Conference Machine Learning, pp- 3259-3269, PMLR, 2020.
Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and William B Dolan. The third pascal rec- ognizing textual entailment challenge. In Proceedings of the ACL-PASCAL workshop on textual entailment and paraphrasing, pp. 1-9, 2007.
Vipul Gupta, Santiago Akle Serrano, and Dennis DeCoste. Stochastic weight averaging in parallel: bargh-batch training that generalizes well. International Conference on Learning Representa- tions, 2020.
Pengcheng He, Jianfeng Gao, and Weizhu Chen. Debertav3: pre-training with gradient-disentangled embedding sharing, 2021.
Improving deberta using clectra-style
Eduard Hovy, Mitch Marcus, Martha Palmer, Lance Ramshaw, and Ralph Weischedel. Ontonotes: the 90% solution. In Proceedings of the human language technology conference of the NAACL, Companion Volume: Short Papers, pp. 57-60, 2006.
Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. In UAI, 2018.
10

---

Published as a conference paper at ICLR 2023
Simran Khanuja, Melvin Johnson, and Partha Talukdar. Mergedistill: Merging language models using pre-trained distillation. In Findings of the Association for Computational Linguistics: ACL- IJCNLP 2021, pp. 2874-2887 2021.
Margaret Li, Suchin Gururangan, Tim Dettmers, Mike Lewis, Tim Althoff, Noah Smith, and Luke Zettlemoyer. Branch-train-merge:: Embarrassingly parallel training of expert language models. arXiv preprint urXiv:2208.0333 2022.
Xiang Li, Kaixuan Huang, Wenhao Yang. Shusen Wang, and Zhihua Zhang. On the convergence of fedavg on non-iid data. In International Conference on Learning Representations, 2019.
Yanran Li, Hui Su, Xiaoyu Shen, Wenjie Li, Ziqiang Cao, and Shuzi Niu. Dailydialog: A manually labelled multi-turn dialogue dataset. arXiv preprint arXiv:1710.03997. 2017
Bill Yuchen Lin, Chaoyang He, Zihang Ze, Hulin Wang. Yufen Hua, Christophe Dupuy, Rahul Gupta, Mahdi Soltanolkotabi, Xiang Ren, and Salman Avestimehr: FedNLP: Benchmarking fed- erated learning methods for natural language processing tasks. Findings of the Association for
Computational Linguistics: NAACL 2022, pp. 157-175, Seattle, United States, July 2022.
Vicki Liu, Carmen Banea, and Rada Mihalcea. Grounded emotions. In 2017 Seventh International Conference on Affective Computing and Intelligent Interaction (ACII), pp. 477-483. IEEE, 2017.
Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint 19t.:19977.1192 2019.
Raphael Gontijo Lopes, Stefano Fenu, and Thad Starner. Data-free knowledge distillation for deep neural networks. NIPS Workshop on Learning with Limited Data, 2017.
Michael Matena and Colin Raffel. Merging models with fisher-weighted averaging. arXiv preprint arXiv:2111.09832, 2021.
Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication--ffice learning of deep networks from decentralized data. In Artificial intelli- gence and statistics, pp. 1272-1282. PMLR, 2017.
Saif Mohammad. emotional tweets. In * SEM 2012: The First Joint Conference on Lexical cictuniicsVollume I: Proceedings of the main conference and the shared task, and Volume 2: Proceedings of the Sixth International Workshop Semantic Evaluation (SemEval 2012), pp. 246-255, 2012.
and Computational
Saif Mohammad and Felipe Bravo-Marquez. Wassa-2017 shared task emotion intensity. In Proceedings of the 8th Workshop on Computational Approaches to Subjectivity, Sentiment and Social Media Analysis. pp. 34-49, 2017.
Saif M Mohammad, Xiaodan Zhu, Svetlana Kiritchenko, and Joel Martin. Sentiment, emotion, purpose, and style in electoral tweets. Information Processing & Management, 51(4))480-49) 2015.
Gaurav Kumar Nayak, Konda Reddy Mopuri, Vaisakh Shaj, Venkatesh Babu Radhakrishnan, and Anirban Chakraborty. Zero-shot knowledge distillation in deep networks. In International Con- ference on Machine Learning, pp. 4743-4751. PMLR, 2019.
Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer learn- ing? In Proceedings of the 34th International Conference on Neural Information Processing Systems, pp. 512-523, 2020.
Dang Nguyen, Khai Nguyen, Dinh Phung, Hung Bui, and Nhat Ho. Model fusion of heterogencous neural networks via cross-layer alignment. arXiv preprint arXiv:2110. 15538, 2021.
Laura Ana Maria Oberländer and Roman Klinger. An analysis of annotated corpora for emotion classification in text. In Proceedings of the 27th International Conference on Computational Linguistics, pp. 2104-2119, 2018.
11

---

Published as a conference paper at ICLR 2023
David Opitz and Richard Maclin. Popular ensemble methods: An empirical study. Journal of Artificial Intelligence Research, 11:169-198, 1999.
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf. Ed- ward Yang, Zach Vito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In NeurlPS, 2019.
Jason Phang, Thibault Févry, and Samuel R Bowman. Sentence encoders stilts: Supplementary training on intermediate labeled-data tasks. arXiv preprint arXiv: 18/ 1.01888, 2018.
Clifton Poth, Jonas Pfeiffer, Andreas Rücklé, and Iryna Gurevych. What to pre-train on? Efficient intermediate task selection. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 10585-10605, Online and Punta Cana, Dominican Republic, November 2021.
Yada Pruksachatkun, Jason Phang. Haokun Liu, Phu Mon Htut, Xiaoyi Zhang, Richard Yuanzhe Pang. Clara Vania, Katharina Kann, and Samuel R. Bowman. Intermediate-task transfer learning with pretrained language models: When and why does it work? In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 1231-5247, Online, July 2020.
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J Liu, et al. Exploring the limits of transfer learning with a unified text-to-text transformer. Mach. Learn. Res., 21((40):1161 2020.
Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100,000+ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 2383-2392. 2016.
Alexandre Ramé, Matthieu Kirchmeyer, Thibaud Rahier, Alain Rakotomamoniy, Patrick Gallinari, and Matthieu Cord. Diverse weight averaging for out-of-distribution generalization. ArXiv, abs/2205.09739, 2022.
Shruti Rijhwani and Daniel Preotiuc- Pietro. Temporally-informed analysis of named entity recogni- tion. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 7605-7617, Online, July 2020.
Lior Rokach. Ensemble-based classifiers. Artificial intelligence review, 33(1):1-39, 2010.
Erik Tjong Kim Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Language- independent named entity recognition. In Proceedings of the Seventh Conference on Natural Language Learning at HLT-NAACL 2003, pp. 142-147, 2003.
Klaus R Scherer and Harald G Wallbott. Evidence for universality and cultural variation of dif- ferential emotion response patterning. Journal of personality and social psychology, 66(2):310, 1994.
Hendrik Schuff, Jeremy Barnes, Julian Mohme, Sebastian Padó, and Roman Klinger. Annotation, modelling and analysis of fine iin-grained emotions on a stance and sentiment detection corpus. In Proceedings of the 8th Workshop on Computational Approaches Subjectivity, Sentiment and Social Media Analysis, pp. 13-23, 2017.
Sidak Pal Singh and Martin Jaggi. Model fusion via optimal transport. Advances in Neural Infor- mation Processing Systems, 0422005522055. 2020.
Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Y Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language pro- cessing, pp. 1631-1642, 2013.
Carlo Strapparava and Rada Mihalcea. Semeval- 2007 task 14: Affective text. In Proceedings of the Fourth International Workshop on Semantic Evaluations (Sem pp. 70-74, 2007.
12

---

Published as a conference paper at ICLR 2023
Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. In International Conference Learning Representations, 2018.
Hongyi Wang, Mikhail Yurochkin, Yuekai Sun, Dimitris Papailiopoulos, and Yasaman Khazaeni. Federated learning with matched averaging. In International Conference on Learning Represen- tations, 2020a.
Jing Wang, Mayank Kulkarni, and Daniel Preofiuc-Pietro. Multi-domain named entity recogni- tion with genre-aware and agnostic inference. In Proceedings of the 58th annual meeting of the association for computational linguistics, pp. 8476-8488, 2020b.
Yaqing Wang, Subhabrata Mukherjee, Xiaodong Liu, Jing Gao, Ahmed Hassan Awadallah, and Jian- feng Gao. Adamix: Mixture-of-adapee for parameter-efficient tuning of large language models. arXiv preprint arXiv:2205. 12410, 2022.
Alex Warstadt, Amanpreet Singh, and Samuel Bowman. Neural network acceptability judgments. Transactions of the Association for Computationaal Linguistics, 7:625-641 641, 2019.
Orion Weller, Kevin Seppi, and Matt Gardner. When use multi-task learning vs intermediate fine-tuning for pre-trained encoder transfer learning. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers). pp. 272-282, Dublin, Ireland, May 2022.
Adina Williams, Nikita Nangia, and Samuel R Bowman. broad-coverage challenge corpus for sentence understanding through inference. In NAACL-HLT, 2018.
Thomas Wolf, Lysandre Debut. Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierrie Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface's trans- formers: State-of-the-arr natural language processing. ArXiv, abs/1910.03771, 2019.
Mitchell Wortsman, Gabriel Ilharco, Samir Ya Gadre, Rebecca Roelofs, Raphael Gontijo-Lope Ari S Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Komblith, et al. Model soups: averaging weights of multiple fine-tuned models improves accuracy without increasing inference time. In International Conference on Machine Learning, pp. 23965-23998. PMLR, 2022.
13

---

Published as a conference paper at ICLR 2023
A DERIVATION OF THE COMPLETE FORMULATION OF REGMEAN
Consider merging of linear models. We have the optimization problem formulation,
KEK:
min
Σ | -
WT x.I Σ (W W.) Wc)
(3)
where for all i, W, W, E _ X; E IR and A, diag (11, A... Are) > 0. The second term a regularization term that encourages be close W; where As the regularization strength for j-th row of W. Here, Xij can be set as any non-negative values. The optimal solution for this problem is,
KEK: WM
iEk [X
(x
Proof. We compute the gradient of the objective function (noted as L) w.r.t the merged weight W.
0L ow
iEK ( 2AW, 2AW)
Σ
Xx +
(5)
We see convex W.r.t W. Therefore, we may find minizer of L by letting
KEK Σ (X] X,W + AW)) Σ(x A)W*
iEK
(6)
iEK > (x,Tx + A Exxx"x A.WW
iEK
W =
(7)
Usually, in linear regression, the regularization strength A; is manually specified as a constant value. However, in our case, the scale of X X; may differ lot across models, layers, datasets. There- fore, we let A; to scale with X² X;, and set A; diag(X?") X;), where 7 is a fixed scalar, so that,
iEK
iEK
WM 1 (XTx, diag X.))] V (XTx, diag(X) X.))Wa
This formulation equivalent increasing the scale of diagonal items of inner product matrices X X, Decreasing all non-diagonal items of inner product matrices by multiplying a 1 the same effect, as we have done in Sec. 3.3
has
KEK Σ
WM
>
X +
γ diag X.))
X.
X Y
diag (X, W.)
+
1+>
1 1+7
1
9
14

---

Published as a conference paper at ICLR 2023
B DETAILS FOR DATASETS, PREPROCESSING, METRICS, AND TRAINING
GLUE. For GLUE Wang al. 2018) experiments, we use CoLA Warstadt et al. 2019), SST- 2 (Socher et al. 2013). MRPC (Dolan & Brocketi 2005). STS-B (Cer et 2017). MNLI (Williams) ctt al. 2018).QNLI (Raipurkar et al. a QQP, and RTE (Gampiccolo et al. 2007) datasets the GLUE task collections. We run evaluation the official development sets because test labels are hidden. We compute Matthews Correlation for CoLA, Pearson Correlation for STS-B, BB and accuracy for all other tasks.
To study merging models trained on non-i..dd partitions, construct two partitions for each of the GLUE tasks. We first randomly sample "key class" from the task and draw 80% of data of the class from the training set and put them into one partition. The rest of the data constitute the other partition. We uniformly draw exam- ples that do belong the "key class" from one partition to the other so that two partitions have the same number of examples. We uni- formly sub-sample each partition that each partition has 1,000 training examples.
Train
Dev
Test
In-domain
DialyDialog
72,085
10,298
20,596
CrowdFlower
27,818
3,974
7,948
TEC
14.735
2,105
4,211
Tales-Emotion
10,339
1,477
2,955
ISEAR
5,366
766
1,534
Out-of-domain
Emoint
7,102
SSEC
4,868
ElectoralTweets
4,056
Emotion. For emotion classification, we use the preprocessed datasets by Oberländer & Klinger (2018). We DailyDialogs (Li
GroundedEmotions
2,585
AffectiveTexx
1,250
Table 4: Statistics emotion classification datasets.
ct al. 2017), CrowdFlower, TEC (Mohammad Tales-Emotion (Alm al. 2005), and
2012
ISEAR (Scherer & Wallbott 1994) for training domain-specific models. We use Emoint (Moham-
mad
Bravo-Marquez (017). SSEC (Schuff' et al.] (2017). Electorallweets (Mohammad et al, GroundedEmotions (Liu et al. 2017). and AffectiveTTxxt (Strapparava & Mihalcea 2007 as held-out datasets for evaluating oft-oin generalization. All the selected datasets have the classes anger, disgust, fear. joy, sadness, surprise in their label space, while some of them have more classes (e.g. guilt). For in-domain performance of each dataset, we compute Macro-F1 all classes that present in the dataset. For out-of-domain performance, we only compute Macro-F1 over anger, disgust, fear, joy, sadnexs, surprise. some the datasets, inputs may be associated with multiple emotion labels. We therefore formulate the emotion classification task multi-label classification task for all datasets. Table summarizes statistics of the datasets.
2015).
On RoBERTa and DeBERTa, we create binary classifi- cation head for each class. We exclude the classification heads that are not learned in the training process when merging the weights of classification heads e.g. one dataset has the class "guilt" but the other does not, the weights of the classification head for "guilt" of the other model will not be used for merging.
Train
Dev
Test
In domain
OntoNotes:be
12,719
2,269
2,355
OntoNote
13,233
1,598
1,666
OntoNotes:mz
7.793
729
OntoNotes:nw
40,466
6,778
2,702
For T5, we reformulate the task into a sequence-to- sequence format with the template: does the sentence ex- press {class_ ? {sentence): with possible outputs yes or no. Such an example will be created for each class that present in the dataset. During evaluation, we treat the exact match yes as the the prediction of the positive label, and otherwise treat as prediction of the negative label.
OntoNotes:tc
13,162
1,671
1,403
OntoNotes:wb
39,140
5,117
5,103
Out-of- domain
CoNLL Twitter
3,684
2,395
Table 5: Statistics NER datasets.
NER. We use 6 domains (newswire, broadcast news, broadcast conversation, magazine, telephone conversa- tion and web data) in OntoNotes (Hovy et al. 2006) for training domain-specific individual models. For testing out-of-domain generalization. use CoNLL Sang & De Meulder (2003) and a Twitter NER data set Rijhwani & Preotiuc-Pietre (020)). Table summarizes statistics of the datasets.
15

---

Published as a conference paper at ICLR 2023
DailyDialog
CrowdFlower
TEC
Tales-Emotion
ISEAR
DailyDialog
8.22
13.95
16.68
13.38
14.69
CrowdFlower
22.11
28.52
22.78
26.26
TEC
29.90
26.55
31.21
Tales-Emotinn
18.28
24.19
ISEAR
30.06
Table 7: OOD performance when merging two RoBERTa-hass emotion classification models (with same head
initialization) with RegMean. Diagonal items represent OOD performance of individual models. We show OOD performance dependent models used for merging.
Implementation. We use huggingface's 's transformer library (Wolf et al., 2019) to download pre- trained LM checkpoints and fine-tune the models. We specifically note that we use the forward function hook feature in PyTorch (Paszke et al. 2019) to obtaín the inputs of all linear layers in order to compute inner product matrices. It makes the code implementation of RegMean agnostic to the model architecture.
Training Details. We fine-tune DistilBERT- base, RoBERTa-base, and DeBeRTa-larg with an initial learning rate le-5, and fine-tune T5- base with an initial learning rate le-4. We use AdamW optimizer throughout the experiments. The learning rate gradually warms up in the first 6% of training steps and linearly decay 0. We train models with a batch size of 16 and for 10 epochs on GLUE, 30 epochs on emotion clas- sification and 20 epochs on NER. We evaluate the performance of the model after each epoch and resume the best performing checkpoint at the end of training.
In-domain
OOD
37.42
20.55
10
40.09
22.09
40.62
22.64
1,000
38.73
22.61
5,000
40.56
22.78
Table 6: Enumerating different setups of N (numbers batches size for computing inner product ma- trices) in merging all five RoBERTa-baas models fine- tuned on emotion classification datasets. We report av- erage performance over in-domain and out-of-domain (OOD) datasets.
C SENSITIVITY ANALYSIS
Number of batches for computing inner product matrices. our main experiments, we use N 1, 000 batches (of size 16) for computing inner product matrices. We present additional analysis about the effect of and summarize results in Table [ In general, performance improves as we increase N, but the performance soon saturates around N 100.
Alternative methods for regularization. As mentioned in Sec. 3.3 and Appendix A reduce non non-diagonal items of inner product ma- trices by fixed scale a, which has regular- ization effect of encouraging merged weights to be closer to individual model weights. Here present analysis of an alternative regularization method, which adds fixed scalar 33 to diagonal items instead of relatively scaling them.
In-domain Fl
Adding constant to diagonals
8 0.01
28.24 24
3 0.1
33.74
3 = 0.2
39.13
3 0.5
34.70
Relative scaling of non-diagonals 0.1
40.32
We experiment with emotion classification on T5 where regularization seems to be most nec- essary. We merge each pair of models on emotion classification datasets and report the average performance over all pairs (a setting similar to Figure. 3h in Table 8 We see rela- tive scaling achieves clearly better performance than adding constant to diagonals. As mentioned in Appendix A this may be caused by differ- ences in the scale of inputs in different layers, models, and datasets, which makes difficult to find single additive regularizer.
Table 8: Comparison performing regularization by adding a constant to diagonals or relative scaling of non-diagonal of inner product matrices. We merge T5- base Emotion Classification models and evaluate aver- age in-domain Fl.
16

---

Published as conference paper at ICLR 2023
Layer 0
Layer
Layer 2
Layer
Layer 4
Layer
Layer
Layer
Layer
Layer
Layer 10
Layer
(a) Intermediate layers (roberta.encoderllyyer wintermediate..deeeee. of transformer blocks
Layer
Layer
Layer 2
Layer
Layer 4
Layer
Layer
Layer
Layer
Layer
Layer 10
Layer
(b) Output layers watherta.encoder..t layer. corr:.t..uuuudeeeeee of transformer blocks
Figure 7: Visualizing distance between pairs of n weight vectors in WA E mm*** and WB C R m Smaller values are highlighted in the heatmaps. We fine-tune RoBERTa -asee models on two different emotion classification datasets. The resulting matrix 1' is used ground metries for computing optimal transport in weight- based matching (Singh Jaggi 2020
Choice of models to merge and its effeet OOD performance. Table summarizes OOD per- formance when merging each pair of RoBETa- basee emotion classification models with same head initialization with RegMean. We the OOD performance clearly dependent the models cho- sen for merging. Merging TEC and ISEAR models, which correspond to two individual models that achieve best OOD performance, produces model that achieves best OOD performance.
D PERMUTATION MATCHING ALGORITHMS FOR MERGING LANGUAGE MODELS
Several existing works (Singh & Jaggi 2020: Ainsworth et al. 2022) propose algorithms to match weight permutations two models before merging, as models with similar outputs may involve dis- tinct permutations in their weights. However, experiments in these works do not cover transformers LMs. In this section, we present an analysis to address two research questions about permutation matching algorithms in the setup of merging language models fine-tuned from shared pretrained weights: (1) does the issue of weight permutation exist in this setup? (2) do existing permutation matching algorithms improve the performance of model merging?
We experiment with merging two RoBERTa-base models fine-tuned on emotion classification datasets. We visualize results merging models trained tales-Emotion and ISEAR in Figures and g Weight- Matching. We apply weight-based matching in OTFusion (Singh & Jaggi 2020). To find permutations between weight matrices WA and WE in the same layer of two different models, the algorithm computes ground metrics matrix M Rax", where is the dimension of the output. Each element Mij M measures 1 distance between pair of weight vectors W and Wi..
17

---

Published as a conference paper at ICLR 2023
Layer 0
Layer
Layer 2
Layer
Layer 4
Layer
Layer 6
Layer
Layer 8
Layer
Layer 10
Layer 11
(a) Intermediate layers (roberta.enccddrrlayrr' iinnerrmmddataeeddeseeee transformer blocks
Layer 0
Layer
Layer 2
Layer
Layer 4
Layer
Layer 6
Layer
Layer 8
Layer
Layer 10
Layer 11
(b) Output layers (roberta.encodeerlaytt .otppet....uuut.ddeese)) of transformer blocks
Figure 8: Visualizing ZT where Za gelu(W] velu(W]Xxx) and ZB gelu(W] Xa) the activations of the layers. We fine-tune RoBERTa-base models on two different emotion classification datasets, resulting 2 Zz is used for computing activation-based matching in (Ainsworth et al. 2022)
18

---

Published as a conference paper at ICLR 2023
Assuming no permutations in weights, we should expect the diagonal items of M (distance of weight vectors in the corresponding positions) to be much smaller than non-diagone con-digoonal items. Otherwise, we may obtain toiviarivaal permutations by solving optimal transport problem with M.
In Figure 7
we visualize the matrix M on the two-layer MLP after each transformer block, which is the only place where linear layers stacked without residual connections in transformers, making weight permutations most likely to happen. However, in Figure 7 we see clear picture that the diagonal items of M are significantly smaller than non-diagonals. The results imply there is no permutations in weights. In this case, the permutation matrix we obtain by solving optimal transport a trivial identity matrix.
We conjecture that sharing the same pretrained LM weight initialization contributes to stability in training. resulting in no permutations weights. The residual connections in transforms may further prevent weights in other modules from getting permuted.
Activation- Based Matching. We apply activation-based matching in Git Re-Basin (Ainsworth et al. 2022). The algorithms relies on similarity matrix C' R that measures pairwise simi- larity activations over N training examples in a certain layer. More formally, C' is computed as 7 n. where ZA. 7 E NNx are activations at a given layer in the models l'A and Sn. The algo- rithm solves linear assignment problem with to obtain permutations activations. Similarity, there is permutation, expect the diagonal items of C' to be large.
We visualize the matrix Figure g We see different picture from weight- matching that C is far from being diagonal. This allows activation-based matching algorithms to produce non-trivial permutation matrices. However, as we apply these permutations, we obtain performance that is far below simple average without matching. We conjecture that in setup permutations of activations could not faithfully represent permutations in weights. Though we just present empirical findings in this paper, consider figuring out the reasons for such discrepancy interesting future work.
19


Reviews:
[{"review_id": "dny6qB1y-VY", "reviewer": "Reviewer_MwUi", "summary": "", "questions": "", "limitations": "", "rating": 5, "confidence": 4, "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": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "main_review": "", "summary_of_the_paper": "The authors work on merge  individual models built on different training data sets to obtain a single model. More specifically, the authors propose a dataless knowledge fusion which is guided by weights that minimize prediction differences between the merged model and the individual models. ", "summary_of_the_review": "The authors propose a dataless knowledge fusion based on weight merging. The motivation of the proposed method is clear. However, the studies setting comes with many restrictions and generalization ability of this method is somewhat limited. More details can be found in Strength And Weaknesses section.", "strength_and_weaknesses": "Strength\n1. The proposed setting is practical and has its merits in the real world.\n2. The proposed method has clear motivation and derivation. \n3. The authors evaluate the proposed method in several settings including in-domain and out-of-domain,  showing improvements compared to  various baseline. \n\n\nWeakness\n1. One of the motivation is that sharing training data may have data privacy issue. A detailed analysis regarding risks about sharing of  Gram matrices along with the models is needed. \n2. The proposed setting is more or less too specific. To protect the training data privacy, the federated learning serves the similar purpose. The authors did not compare their models to this setting. Another qualified baseline like ensemble is not included in the experimental Table 1. \n3. The improvements are not significant compared to Fisher weight merging on GLUE benchmark.  \n3. The problem setting is limited to that the training data is not allowed to share. It is also helpful to understand if this method is able to bring improvements when training data is allowed to share. Such a setting is more commonly used when studying weight merging.\n4.  The performance improvements brought by weight merging may decay as the training data size increases. The training data is limited to 1000 in  Table 1 without a clear reasons. To better understand the effectiveness of the proposed mechanism,  it is important to study if the weight merging could bring improvements when the training data is in a relatively large scale. ", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "cLmV-w__wrE", "reviewer": "Reviewer_PCeq", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "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": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "main_review": "", "summary_of_the_paper": "This paper presents a simple and well-motivated technique for merging different models in a \"dataless\" way, and evaluates the method in comparison to simple averaging and Fisher-weighted averaging.", "summary_of_the_review": "While this paper presents an elegant and non-trivially effective technique on an important problem, I was not convinced that it explained or evaluated its relationship to previous work well enough for publication.  However, if other reviewers (especially ones more directly familiar with the recent previous work) are enthusiastic about the work, I would not try to stand in the way of acceptance.", "strength_and_weaknesses": "Strengths\n\nThis paper presents an elegant technique and presents it clearly.  It includes a number of helpful experiments that show that the technique performs well, albeit not uniformly better than all baselines.\n\nWeaknesses\n\nThe paper fails to explain some important relationships between its approach and previous work, and may be missing important comparisons.  I also had a question about the ensemble baseline and I think comparing against other ensemble alternatives may be important.  I discuss these in more detail below.\n\nSection 3.2 says it will explain the relationship between the proposed method and Fisher-weighted averaging, but it doesn’t really (it only discusses a distinction between an extreme special case of the proposed method and Fisher, and only very briefly and abstractly).  More discussion of how the proposed approach differs from Fisher and why we would expect it to perform better in certain situations is really critical.\n \nIn the experiments, the paper says the ensemble works “by obtaining logits from all models and doing an argmax”—this is confusing.  Ensembles I’m familiar with tend to average the probability outputs of each model, and then take the argmax of that average.  You could also average the logits (effectively, multiplying the probability outputs).  But taking the max over all the models, which is what this text seems to be saying, is not something I’ve seen.  Maybe I’m just unfamiliar with this approach and/or maybe it works better on these data sets than the other possibilities (especially in this setting with non-iid partitions), but the paper needs to explain this one way or another.\n\nRegarding potentially missing baselines, the last sentence of the model merging paragraph in the related work section mentions several “improved merging algorithms”---how do these differ from the proposed method?  Why does the paper not include an experimental comparison against the best of these?", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "2: The contributions are only marginally significant or novel.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}, {"review_id": "BDCHCaluUu", "reviewer": "Reviewer_hdqV", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": 4, "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": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "main_review": "", "summary_of_the_paper": "This paper focuses on merging individual models on the parameter space without access to the respective training data. The individual models could come from different domains or even different tasks, their knowledge could be fused by merging without any training, and the resulting merging model could perform relatively well on all domains/tasks. Notably, the inference cost after merging is the same as the individual models. The authors propose the Regression Mean (RegMean) method to merge model parameters derived from merging linear models. RegMean uses the Gram matrices of the training data to reweight and linearly combine rows in weight matrices during merging. This paper consists of comprehensive experiments to examine merging multiple models trained on different domains / different tasks and test on in-domain and out-of-domain settings. Empirical results demonstrate the effectiveness of the method compared with recent baselines.", "summary_of_the_review": "I recommend acceptance of this paper since it studies an important and intriguing problem – model parameter merging, proposes new algorithms, and achieves good results in demonstrated comprehensive experiments. The weakness is that the method makes strong assumption on access to the Gram matrices of private training data.\n", "strength_and_weaknesses": "### Strengths:\n\n1. I think the model merging problem studied in this paper is a very important direction to pursue – it is an efficient way of fusing knowledge from multiple large models without training or increasing the inference cost.\n2. The proposed method RegMean is derived clearly from linear regression, and is novel and simple.\n3. The experiments are comprehensive including multiple challenging settings and detailed analysis over pretrained models and hyperparameters. Particularly, the paper tests merging more than 2 models which the Fisher merging paper did not test. I think the insights revealed by these results could be useful for future researchers.\n4. The experimental results of RegMean are good, demonstrating the usefulness of model merging in various settings and outperforming recent baselines like Fisher merging.\n\n\n### Weaknesses:\n\n1. I think one limitation of RegMean is that it requires access to the Gram matrix stats of the training data of each individual model. Even though this is much more reasonable than accessing the original training data, it would still make RegMean not applicable in many cases. This problem exists for Fisher merging as well, and average merging is the most flexible\n2. I would like to see a more detailed discussion on other baselines mentioned in the related work by \"improved merging algorithms\" and why the authors do not compare with them.\n3. I feel some results from this paper are contradictory with the ones in Matena et al. (the Fisher merging paper) – this paper observed performance drop in all pairwise test settings (Figure 3, Figure 4), while Matena et al. observe gains over task-specific models when merging donor tasks with the target task. Particularly, Table A2 in Matena et al.  and Figure 4 in this paper are both on the GLUE tasks but with different conclusions, in Matena et al there is no clear performance drop. I wonder how the authors explain this difference, is it because the pretrained models are different (Bert v.s. DistillBert/Roberta)? The performance drop in pairwise merging seems pretty consistent in this paper though.  \n\n\n\n### Questions:\nIn Table 2, are the results a mixture of test examples from multiple domains? If so, how are domain-specific numbers calculated?\n\n\n```\nUpdate during rebuttal:\n\nI agree with the authors that the permutation lines of work are orthogonal and complementary to this paper, and the added discussion on this aspect is helpful. I also appreciate that the authors clarify my confusions in the response. Therefore, I increase my score to 8.\n```\n", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "4: All of the claims and statements are well-supported and correct.", "technical_novelty_and_significance": "4: The contributions are significant, and do not exist in prior works.", "empirical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work."}, "extra_text": {}}, {"review_id": "6JVm8OXOcJx", "reviewer": "Reviewer_fiB5", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": 4, "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": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "main_review": "", "summary_of_the_paper": "This paper proposes a new strategy for merging the parameters of models which have been fine-tuned on different datasets. The merging algorithm is intended for models which are all fine-tuned from the same base model. The primary contribution of the paper is the algorithm for merging models. The algorithm is formulated as a least squares problem where the goal is to minimize the squared distance between the merged model parameter and the individual model parameters applied to the individual datasets. The authors perform experiments on emotion classification and named entity recognition with a variety of models. They show that their approach improves over alternative prior algorithms though is generally not as good as full multi-task training.", "summary_of_the_review": "The proposed algorithm is novel and an improved solution to the problem the authors describe. The algorithm is also fairly simple to understand and efficient to implement which are good features. The authors also show support that RegMean works well by demonstrating results on two NLP tasks with several models.\n\nMy main concern are the two primary limitations (as discussed above). These limitations might make the situations in which this algorithm is applicable somewhat niche.", "strength_and_weaknesses": "Strengths:\n\n- The algorithm is simple to understand, well justified, and as far as I can tell novel (though I am not that familiar with prior work for this specific task).\n- The RegMean algorithm appears to work better than existing alternatives (simple averaging and Fisher averaging) while being roughly as efficient in terms of computation time and memory.\n- The empirical results are well carried out with good baselines and comparisons for different models.\n\nWeaknesses:\nI have two concerns with this algorithm which I think should be addressed more prominently than they are. They are a bit buried late in the intro or the methodology sections.\n- First, the algorithm is really only intended to work in the case where every model starts from the same pertained baseline. It's pretty clear the algorithm would not work even for the same model architecture trained on the same dataset with a different random initialization as there is no attempt to solve the permutation problem. I would recommend being more upfront with this limitation.\n- Second, the primary justification for this approach is to maintain data privacy (since otherwise the models could all be trained on the data). However, the algorithm reveals the quite a bit of data for each task, roughly the size of the model which can be fairly large. I would be more upfront in discussing this weakness.\n- The algorithm is only used for \"linear\" layers. It would be interesting if it the authors also examined how well it worked for other types of layers (the self-attention matrices, convolutional layers, etc.).\n\n\nOther minor comments:\n\n- \"Margin Models Trained on Different Tasks\": Point of experiment unclear.\n- Results in Table 3 for Fisher under DeBERTa-large for Emotion with same/diff are very strange. Why does using a different head result in such a huge performance improvement compared to the same head?\n- In Figure 6a does it make much difference which two models you choose? Or is performance just worse when you go from any two models to three and so on.\n- Did you try experiments with using just a simple regularization (e.g. adding some small value to the diagonal of the Hessian prior to inversion)? I notice you scale the diagonal up in your algorithm but I'm curious if you tried the simpler/more traditional alternative and how it compared?\n- In the computation of the input features for each layer's regression problem you use 1000 batches (section 3.4?). How important is this parameter? Is the performance of the algorithm quite sensitive to it or not that much?\n\nNits:\n\n- The Gram matrix is usually the matrix of sample size x sample size - the matrices that come up in the normal equations e.g. X^T X aren't usually called Gram matrices. I would avoid using this name as it is confusing.\n- In section 3.4, 1k means 1,000? I would just write it out for clarity.\n- Unneeded period after \"Figure. 5a\" at the bottom of page 8.\n", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "4: All of the claims and statements are well-supported and correct.", "technical_novelty_and_significance": "4: The contributions are significant, and do not exist in prior works.", "empirical_novelty_and_significance": "4: The contributions are significant, and do not exist in prior works."}, "extra_text": {}}]

Author rebuttal:

Decision: Accept: poster