Wolf2Pack: The AutoFusion Framework for Dynamic Parameter Fusion

## Abstract

Abstract In the rapidly evolving field of deep learning, specialized models have driven significant advancements in tasks such as computer vision and natural language processing. However, this specialization leads to a fragmented ecosystem where models lack the adaptability for broader applications. To overcome this, we introduce AutoFusion , an innovative framework that fusing distinct model’s parameters(with the same architecture) for multi-task learning without pre-trained checkpoints. Using an unsupervised, end-to-end approach, AutoFusion dynamically permutes model parameters at each layer, optimizing the combination through a loss-minimization process that does not require labeled data. We validate AutoFusion’s effectiveness through experiments on commonly used benchmark datasets, demonstrating superior performance over established methods like Weight Interpolation, Git Re-Basin, and ZipIt. Our framework offers a scalable and flexible solution for model integration, positioning it as a powerful tool for future research and practical applications.

## 1 Introduction

In the rapidly evolving landscape of technological innovation, deep learning models have become increasingly specialized [] [] [] [] [], leading to substantial advancements in diverse fields such as computer vision and natural language processing []. These specialized models, meticulously honed to excel in their designated niches, have undeniably propelled numerous breakthroughs []. However, this specialization has inadvertently led to a fragmented ecosystem where models, although highly effective within their specific domains, lack the adaptability and versatility required to address a wider array of challenges. This raises a pivotal question: Is it possible to amalgamate the strengths of these specialized models into a unified architecture capable of performing multiple tasks proficiently?

The challenge of integrating specialized models into a coherent system is multifaceted. Traditional approaches to model fusion heavily depend on prior knowledge and require meticulous tuning of hyperparameters, such as specifying which layers to merge and permuting parameters according to what principle. [] [] []. Do we have to propose a new approach to any new problem? This is obviously costly and has a serious impact on the usefulness of parametric fusion. Moreover, In the case where model parameters do not share pre-trained parameters, merging parameters from different tasks obviously cannot be directly accomplished through the previously common method of parameter permutation based on similarity.

To address these challenges, we propose AutoFusion, an innovative framework designed to fuse the parameters of two models, which do not share the same pre-trained parameters and perform different tasks, into a single parameter capable of simultaneously accomplishing multiple tasks which can be expressed figuratively as Figure 1. Drawing inspiration from the principle that ’more is merrier’, unlike conventional methods that depend on predefined rules or heuristics, AutoFusion aims to learn an effective permutation of model parameters to accomplish the fusing of multi-task model parameters. This unsupervised training process requires no labeled data, making it a flexible and scalable solution for model integration.

Figure: Figure 1: Hand-designed fusion algorithms tend to rely on a priori, resulting in lower flexibility and suboptimal results, but our goal is to build a data-driven, learnable fusion algorithm to approximate the optimal solution.
Refer to caption: x1.png

The AutoFusion method is primarily based on two operations: aligning parameters that perform similar functions through permutation, and retaining parameters that perform different functions through their permutation as much as possible. Thanks to the end-to-end design of AutoFusion, the permutations relied upon by these two operations are both learned through the design of corresponding loss functions.

To evaluate the efficacy of AutoFusion, we conducted experiments on the commonly used benchmark datasets [] [] [] [], simulating the scenario of merging models trained on distinct tasks. Our findings indicate that the merged model achieves high accuracy across all sub-tasks, frequently outperforming established techniques like Weight Interpolation [], Git Re-Basin [], and ZipIt [].

Our contributions to the field of model parameter integration can be summarized as follows:

(i) End-to-End Unsupervised Framework: We present an end-to-end, unsupervised approach to model parameter fusion, eliminating the need for prior knowledge and predefined hyperparameters. This approach facilitates the dynamic permuting of model parameters at each layer, resulting in a unified and robust model capable of handling multiple tasks.

(ii) Empirical Validation and Performance: Through extensive experimentation on the commonly used benchmark datasets, we demonstrate the superior performance of AutoFusion compared to established methods such as Weight Interpolation, Git Re-Basin, and ZipIt. Our framework achieves high accuracy across all sub-tasks, highlighting its effectiveness in multi-task scenarios.

(iii) Scalability and Flexibility: The unsupervised nature of AutoFusion ensures its scalability and flexibility, allowing it to be applied to a wide range of model architectures and datasets without the need for labeled data. This characteristic positions our framework as a versatile tool for future research and practical applications in deep learning. In particular, as we use an end-to-end approach to learn parameter permutations, the design of the method is limited to the design of the loss function. By learning different meanings of permutations through different loss functions, the method demonstrates great flexibility.

AutoFusion represents a significant stride forward in the field of model parameter fusion. By offering an end-to-end, unsupervised approach to model fusion, we aim to unify the disparate threads of specialized deep-learning models into a cohesive, adaptable ecosystem. This work not only advances the state-of-the-art in model fusion but also paves the way for future research into more versatile and efficient deep-learning architectures. Our code is available at https://github.com/TianSuya/autofusion.

## 2 Preliminary

The main problem addressed in our work can be defined as follows: in the absence of shared pre-trained parameters (without sharing the optimization process), we aim to fuse the parameters of two identical architecture models trained separately on disjoint tasks to obtain a fused model []. The expectation is that this fused model can retain, to the greatest extent possible, the capabilities of each model before fusion.

If two datasets of disjoint tasks are recorded as datasets A and B:

$$ $\mathcal{D}_{i}=\{(x_{j},y_{j})|j\in N^{i}\},i\in\{A,B\}$ (1) $$

where $N^{i}$ indicates the number of samples in the dataset $\mathcal{D}_{i}$.
Suppose the cross-entropy loss can be expressed as $\mathcal{H}(\cdot)$, then the models trained on datasets A and B can be represented as $\Theta_{i},i\in\{A,B\}$, where $\Theta_{i}$ is derived from the following formula:

$$ $\mathop{argmin}\limits_{\Theta_{i}}\frac{1}{N^{i}}\sum\limits_{j=0}^{N^{i}} \mathcal{H}(P_{m}(x_{j}|\Theta_{i}),y_{j})$ (2) $$

$P_{m}(\cdot)$ represents the predicted output of input $x_{j}$ based on the model parameter $\Theta_{i}$.
when we get the parameters of the two models, $\Theta_{A}$ and $\Theta_{B}$. Next, let’s assume that the model’s parametric fusion operation can be represented as:

$$ $\Theta_{merged}=\mathcal{M}(\Theta_{A},\Theta_{B})$ (3) $$

Our goal is to find an $\mathcal{M}$ that minimizes the joint loss of the fused model $\Theta_{merged}$ on datasets A and B, which can be expressed as:

$$ $\mathop{argmin}\limits_{\mathcal{M}}\frac{1}{2}\sum\limits_{i=A}^{\{A,B\}} \frac{1}{N^{i}}\sum\limits_{j=0}^{N^{i}}\mathcal{H}(P_{m}(x^{i}_{j}|\Theta_{ merged}),y^{i}_{j})$ (4) $$

### 2.1 Weight Interpolation

Early parametric fusion relied primarily on the ability to perform arithmetic averaging directly to the model’s parameters to integrate the model [] [] [] [] [], a process that can be represented as:

$$ $\mathcal{M}(\Theta_{A},\Theta_{B},\gamma)=\gamma\Theta_{A}+(1-\gamma)\Theta_{B }=\{\gamma W_{A}^{l}+(1-\gamma)W_{B}^{l}|l\in[0,L)\}$ (5) $$

where $L$ denotes the number of layers of the model, and the parameters $W$ of each layer are treated as a vector in space $\mathbb{R}^{d_{l}}$, and $\gamma$ always set to $\frac{1}{2}$.

However, this method is quite crude. When the two models do not share common pre-trained parameters, their parameters often cannot be directly corresponded due to the permutation invariance of neural networks, making it difficult to obtain valuable results through direct linear interpolation [] [] [] [].

### 2.2 Re-basin

Addressing the issues arising from directly applying linear interpolation to parameters, studies [] [] [] propose that since randomly permuting neurons within a neural network does not affect the final output, we can first align the parameters of two models by permutation. This involves corresponding neurons responsible for the same functions to the same positions in both models before performing linear interpolation. This process can be represented as follows:

$$ $\mathcal{M}(\Theta_{A},\Theta_{B},\gamma)=\gamma\Theta_{A}+(1-\gamma)\pi( \Theta_{B})=\{\gamma W_{A}^{l}+(1-\gamma)P_{l}W_{B}^{l}P^{T}_{l-1}|l\in[0,L)\}$ (6) $$

where $\pi(\cdot)$ represents the transformation using the corresponding permutation matrix $P$ for each layer, $P_{l}\in\pi$ represents the permutation matrix of layer $l$, and to eliminate the influence of the layer $l-1$ permutation on the current layer, it is also multiplied by the inverse matrix of the layer $l-1$ permutation matrix $P^{-1}_{l-1}$, but since the permutation matrix is orthogonal, its inverse matrix is equal to its transpose matrix $P^{T}_{l-1}$.
The permutation matrix $P$ is solved using the layer-by-layer greedy linear assignment method(Hungarian Algorithm).
The goal of the method optimization can be expressed as:

$$ $\mathop{argmin}\limits_{\pi}d(\Theta_{A},\pi(\Theta_{B}))$ (7) $$

where $d(\cdot)$ denotes the distance between the two model parameters, which can be further expressed as:

$$ $d(\Theta_{A},\pi(\Theta_{B}))=\frac{1}{L}\sum\limits_{l=0}^{L-1}\parallel W_{A }^{l}-P_{l}W_{B}^{l}P^{T}_{l-1}\parallel^{2}$ (8) $$

This method can align neurons with similar functions to a certain extent, allowing for the integration of parameters from two models through linear interpolation without losing accuracy. However, such an operation tends to make the parameters of the two models similar, making it unsuitable for scenarios where different models need to retain their diversity when merging multi-task models.

### 2.3 Model Zip

In the context of the aforementioned research, Zipit [], for the first time, proposed a method targeting the issue of multi-task parameter fusion without pre-trained parameters. This method considers the activation values of each layer’s output in the model, employing a merging matrix to combine features with high correlation while utilizing an unmerging matrix to reverse the merging when features cannot be effectively combined.

If we express the activation value of layer l as $f_{l}$, Then we can express the above operation as:

$$ $f^{*}_{l}=M_{l}(f_{l}^{A}\parallel f_{l}^{B}),\ U_{l}f_{l}^{*}\simeq f_{l}^{A} \parallel f_{l}^{B}$ (9) $$

where $\parallel$ stands for combination operation. Unlike previous work, Zipit takes into account the self-matching of activation values.

After getting $U$ and $M$ matrices, Zipit uses these matrices to transform the parameters and fuse the parameters:

$$ $W_{l}^{*}=M_{l}^{A}W_{A}^{l}U^{A}_{l-1}+M_{l}^{B}W^{l}_{B}U_{l-1}^{B}$ (10) $$

Although Zipit’s model compression method has improved the effectiveness of multi-task model fusion to some extent, it remains confined to merging similar functionalities through parameter permutation. The approach adopted by Zipit, which enhances fusion by forsaking the merging of layers with weaker similarities, does not genuinely address the underlying issues of multi-task merging but rather serves as a compromise solution out of necessity. Therefore, it is evident that exploring model parameter fusion methods under complete merging scenarios remains imperative.

## 3 AutoFusion

AutoFusion proposes a novel parameter fusion method to address the issue of multi-task model parameter fusion in the absence of pre-trained parameters. An overview of the AutoFusion method is shown in Figure 2. The specific design methodology is detailed in the following subsections.

Figure: Figure 2: This is an overview of our AutoFusion methodology, implementation details can be found in section 3
Refer to caption: x2.png

### 3.1 From Rule-based to End-to-end

Existing methods primarily rely on manually designed rules for parameter alignment, which are limited by the assumption that parameters of the same layer should exhibit high similarity. However, this assumption of high similarity falls apart when the models to be merged are trained for different tasks. During merging, we must not only align parameters with similar functions but also strive to retain parameters with distinct functions, enabling the fused model to perform various tasks simultaneously.

Determining which parameters with different functions to retain is a challenge that cannot be easily addressed through prior knowledge []. It cannot be achieved through simple similarity metrics and straightforward rules, as is the case with parameter similarity alignment. This compels us to consider advancing towards an end-to-end approach, where model parameter fusion is accomplished directly through learning.

If we attempted to utilize neural functional functions from neural functional analysis to predict network parameters from network parameters [] [] []. Specifically, employing permutation-invariant neural networks to directly accept network parameters as input and output the fused network parameters:

$$ $vec(\Theta^{*})=\Psi(vec(\Theta^{A}),vec(\Theta^{B}))$ (11) $$

where $vec(\cdot)$ represents flattening the parameter to a high-dimensional vector, $\Psi(\cdot)$ denotes the neural function used for fusion. However, the excessively large number of parameters in this scheme results in high training costs, making it challenging for practical application. Considering that the rows and columns of the model parameter matrix inherently contain complete information, and the cost required to learn the permutation matrix is minimal, this naturally leads us to shift our focus towards learning the parameter permutation matrix.

Inspired by [] and [], we employ the Sinkhorn operator to convert the discrete permutation matrix into a differentiable form to satisfy the criteria for gradient descent optimization, first defining:

$$ $S_{\tau}(X)=\mathop{argmax}\limits_{P\in\pi}\langle P,X\rangle_{F}+\tau h(P)$ (12) $$

where $\langle A,B\rangle_{F}$ represents $trace(A^{T}B)$, and $\pi$ represents the set of all permutation matrices that have the same shape as $X$, $X$ is a $N$ dimensional square matrix. $h(P)$ represents the entropy regularizer $-\sum_{i,j}P_{i,j}logP_{i,j}$, and $\tau$ represents it’s weight.

Equation 12 is known as the Sinkhorn operator, the matching operation of the permutation matrix is not differentiable, but [] proves that a differentiable computational step can approximate it:

$$ $\displaystyle S_{\tau}^{(0)}(X)$ $\displaystyle=exp(X/\tau)$ (13) $\displaystyle S_{\tau}^{(t+1)}(X)$ $\displaystyle=\mathcal{T}_{c}(\mathcal{T}_{r}(S_{\tau}^{(t)}(X)))$ $$

where $X\in\mathbb{R}^{n\times n}$, it can be seen as a soft version of the permutation matrix, $\mathcal{T}_{r}(X)$ and $\mathcal{T}_{c}(X)$ represent the operation of normalizing the rows and columns of the matrix, respectively, can be calculated as $X\oslash(X\mathbf{1}_{n}\mathbf{1}_{n}^{T})$ and $X\oslash(\mathbf{1}_{n}\mathbf{1}_{n}^{T}X)$ where $\oslash$ stands for element-wise division. [] proves that when $t\rightarrow\infty$, Equation 13 converges to Equation 12.

To prove the credibility of this approximation, we derive the upper error bound between it and the Sinkhorn operator:

Theorem (Error Bound for the Sinkhorn Operator): For any fixed $\tau>0$, the approximation error $\mathcal{E}$ satisfies the following inequality:

$$ $\mathcal{E}\leq\frac{\|X\|_{\infty}^{2}}{2\tau}$ (14) $$

The detailed proof process and differentiability of approximate calculations are given in Appendix A.

This then allows us to learn the appropriate parameter permutation matrix by setting up the appropriate loss function, and the process of merging can be expressed as:

$$ $\displaystyle\mathcal{M}_{AF}(\Theta_{A},\Theta_{B},\gamma)$ $\displaystyle=\gamma\Theta_{A}+(1-\gamma)\pi(\Theta_{B})$ (15) $\displaystyle=\{\gamma W_{A}^{l}+(1-\gamma)S_{\tau}(X_{l})W_{B}^{l}S_{\tau}(X_ {l-1}^{T})|l\in[0,L)\}$ $$

### 3.2 Design of Optimization Targets

We have now constructed a learnable permutation matrix using the Sinkhorn operator, which can be directly applied to parameter fusion. Therefore, the next step is to design a reasonable optimization objective to refine the permutation matrix, enabling the fused model to integrate parameters for common functionalities while preserving the necessary parameter diversity for handling multiple tasks.

According to the conclusions of [] [] [], some representations learned by neural networks tend to have strong generality, and the generality representations can often be merged through parameter alignment to improve the stability of the network for these representations [].

To align these neurons, we designed a weighted parametric alignment loss:

$$ $\mathcal{L}_{align}=\frac{1}{L}\sum\limits_{l=0}^{L}\omega(l)\cdot\parallel W_ {A}^{l}-S_{\tau}(X_{l})W_{B}^{l}S_{\tau}(X_{l-1}^{T})\parallel^{2}$ (16) $$

where $\omega(l)$ represents the loss weight of the current layer $l$. The reason for performing layer-wise weighting is that most studies have shown that features learned by shallow-layer neurons tend to be more generalizable. In AutoFusion, we chose to set $\omega(l)$ for each layer by linear relationship $\omega(l)=\frac{2L}{l}$.

To encourage the permutation matrix learned by the model to retain features that can handle multiple tasks to a certain extent, we randomly sampled a batch of input data from multi-task dataset $\mathcal{D}_{sampled}=\{x_{i}|i\in[0,N_{s})\}$. Our goal is to leverage accessible model parameters to obtain reliable pseudo-labels for this data without accessing their true labels, thereby assisting in the training of the permutation matrix. Firstly, we utilized existing models A and B to obtain their predictions for this data:

$$ $\displaystyle\widehat{Y}_{A}$ $\displaystyle=\{y^{i}_{A}=P_{m}(x_{i}|\Theta_{A})|x_{i}\in\mathcal{D}_{sampled}\}$ (17) $\displaystyle\widehat{Y}_{B}$ $\displaystyle=\{y^{i}_{B}=P_{m}(x_{i}|\Theta_{B})|x_{i}\in\mathcal{D}_{sampled}\}$ $$

Next, we define $\mathbb{C}(\cdot)$ that can choose the one with higher confidence from the prediction output of the two models as the final output:

$$ $\mathbb{C}(y_{A},y_{B})=\mathbb{I}(\max(y_{A})>\max(y_{B}))\cdot y_{A}+\mathbb {I}(\max(y_{B})>\max(y_{A}))\cdot y_{B}\\$ (18) $$

where $\mathbb{I}(\cdot)$ is the indicator function, with a value of $1$ when the conditions are met and a value of 0 0 when the conditions are not met. Next, we can use $\mathbb{C}(\cdot)$ to complete the screening of the output of the two models:

$$ $\widehat{Y}=\{y^{i}=\mathbb{C}(y_{A}^{i},y_{B}^{i})|y_{A}^{i}\in\widehat{Y}_{A },y_{B}^{i}\in\widehat{Y}_{B}\}$ (19) $$

After obtaining $\widehat{Y}$, it is necessary to construct a computational graph containing the parameters of the permutation matrix to be trained through operations, to complete supervised learning. Inspired by [], we sample a fusion coefficient $\gamma_{t}$ from a uniform distribution represented as $\gamma_{t}\sim U(0,1)$ and fuse the models to be combined using the existing permutation matrix following the method of Equation 15:

$$ $\Theta_{merged}=\mathcal{M}_{AF}(\Theta_{A},\Theta_{B},\gamma_{t})$ (20) $$

Next, the permutation matrix optimization goal that retains multitasking capabilities can be expressed as:

$$ $\mathcal{L}_{retain}=\mathbb{I}(max(y^{i})>\zeta)\cdot\mathcal{H}(P_{m}(x_{i} \Theta_{merged}),y_{i})$ (21) $$

where, $y_{i}\in\widehat{Y}$, paired one-to-one with $x_{i}$, and $x_{i}$ is the input sample from $\mathcal{D}_{sampled}$ and $\zeta$ is a hyperparameter that represents the selected confidence threshold to filter low confidence predictions. Now we can optimize the permutation matrix by combining $\mathcal{L}_{align}$ and $\mathcal{L}_{retain}$ together for training:

$$ $\mathcal{L}=\omega_{a}\cdot\mathcal{L}_{align}+\omega_{r}\cdot\mathcal{L}_{retain}$ (22) $$

where $\omega_{a}$ and $\omega_{r}$ are the weights of $\mathcal{L}_{align}$ and $\mathcal{L}_{retain}$, respectively. It is important to note that during the whole training process, only the permutation matrix of the parameters will be trained, and the parameters of any model will not save the gradient.

## 4 Results

Due to the scarcity of work on multi-task model parameter fusion without pretraining, we have partially adopted the settings from [] in designing our experiments. In Table 1, we split several commonly used benchmark datasets in computer vision into non-overlapping subsets based on their categories, trained models on these subsets independently, and compared the effects of parameter fusion using different methods and different network structures. We have also included crucial ablation experiments subsection 4.2 and parameter experiments in Appendix C to comprehensively evaluate the method’s effectiveness and parameter sensitivity. In subsection 4.4, we present some visualization results to demonstrate the model’s effectiveness from a more intuitive perspective.

### 4.1 Comparison with other Methods

**Table 1: AutoFusion test results on different feature extraction networks and different datasets.**
| Dataset | Method | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| MINIST(5+5)<br>MLP | Model A | $58.92\pm 0.01$ | $97.26\pm 0.01$ | $19.42\pm 0.01$ | $58.34$ |
| Model B | $53.00\pm 0.01$ | $9.45\pm 0.01$ | $97.84\pm 0.01$ | $53.65$ |  |
| Weight Interpolation | $53.06\pm 0.01$ | $67.99\pm 0.01$ | $37.67\pm 0.01$ | $52.83$ |  |
| Git Re-Basin | $50.08\pm 0.4$ | $45.12\pm 1.1$ | $52.99\pm 1.0$ | $49.06$ |  |
| Zipit | $51.25\pm 0.6$ | $57.31\pm 1.2$ | $45.00\pm 0.7$ | $51.25$ |  |
| AutoFusion | $\mathbf{85.85}\pm 0.7$ | $\mathbf{88.56}\pm 0.8$ | $\mathbf{83.04}\pm 0.8$ | $\mathbf{85.80}$ |  |
| CIFAR-10(5+5)<br>MLP | Model A | $45.16\pm 0.01$ | $62.30\pm 0.01$ | $28.02\pm 0.01$ | $45.16$ |
| Model B | $43.83\pm 0.01$ | $24.01\pm 0.01$ | $63.56\pm 0.01$ | $43.83$ |  |
| Weight Interpolation | $20.01\pm 0.01$ | $20.00\pm 0.01$ | $20.02\pm 0.01$ | $20.01$ |  |
| Git Re-Basin | $40.12\pm 0.3$ | $37.13\pm 0.4$ | $\mathbf{44.01}\pm 0.2$ | $40.57$ |  |
| Zipit | $40.58\pm 0.2$ | $38.48\pm 0.3$ | $42.68\pm 0.2$ | $40.58$ |  |
| AutoFusion | $\mathbf{45.10}\pm 0.1$ | $\mathbf{47.47}\pm 0.1$ | $42.76\pm 0.2$ | $\mathbf{45.12}$ |  |
| MINIST(5+5)<br>CNN | Model A | $57.11\pm 0.01$ | $97.85\pm 0.01$ | $10.39\pm 0.01$ | $54.12$ |
| Model B | $54.35\pm 0.01$ | $17.24\pm 0.01$ | $98.86\pm 0.01$ | $58.05$ |  |
| Weight Interpolation | $21.15\pm 0.01$ | $22.34\pm 0.01$ | $19.89\pm 0.01$ | $21.12$ |  |
| Git Re-Basin | $52.08\pm 1.1$ | $19.15\pm 1.8$ | $85.99\pm 1.0$ | $52.57$ |  |
| Zipit | $52.00\pm 0.6$ | $50.19\pm 1.2$ | $52.31\pm 0.7$ | $51.25$ |  |
| AutoFusion | $\mathbf{65.23}\pm 0.2$ | $\mathbf{58.65}\pm 0.3$ | $\mathbf{72.58}\pm 0.2$ | $\mathbf{65.62}$ |  |
| CIFAR-10(5+5)<br>CNN | Model A | $45.69\pm 0.01$ | $81.34\pm 0.01$ | $26.01\pm 0.01$ | $53.67$ |
| Model B | $44.31\pm 0.01$ | $23.86\pm 0.01$ | $83.66\pm 0.01$ | $53.67$ |  |
| Weight Interpolation | $20.01\pm 0.01$ | $20.05\pm 0.01$ | $20.11\pm 0.01$ | $20.08$ |  |
| Git Re-Basin | $39.41\pm 0.3$ | $30.32\pm 0.4$ | $45.15\pm 0.5$ | $37.73$ |  |
| Zipit | $47.65\pm 0.4$ | $48.78\pm 1.2$ | $45.99\pm 1.3$ | $47.38$ |  |
| AutoFusion | $\mathbf{52.85}\pm 0.7$ | $\mathbf{53.24}\pm 0.5$ | $\mathbf{52.46}\pm 0.6$ | $\mathbf{52.85}$ |  |

Baselines To assess the superiority of AutoFusion, we selected several widely used methods in the field of parameter fusion as our comparison objects, namely Weight Interpolation, Git Re-Basin[], and Zipit[]. Among them, Git Re-Basin represents the most widely used solution for mainstream parameter alignment methods, and after testing, we only chose the Weights Matching method, which yielded the best results. Zipit, on the other hand, is the first method specifically designed to address multi-task parameter fusion without pretraining. Weight Interpolation is the most straightforward method in parameter fusion. We also included data from directly evaluating the unfused model to highlight the effectiveness of the parameter fusion methods.

Datasets We selected two commonly used benchmark datasets in the field of computer vision, MNIST and CIFAR-10, both of which are 10-class datasets. Using random sampling, we split these 10-class datasets into two non-overlapping 5-class datasets, denoted as Dataset A and Dataset B, following the settings in section 2. Subsequently, we independently trained models on the divided datasets to obtain the multi-task models ready for fusion.

Settings To comprehensively evaluate the performance of AutoFusion under different architectures, we selected MLP and CNN (VGG)[] as the base networks for evaluation. We independently trained models on different model architectures and different parts of datasets. We used various fusion methods for parameter fusion and analyzed the accuracy of the fused models. The "Joint" column represents the accuracy of the current model tested on the undivided dataset, while "Task A" and "Task B" represent the accuracy of the model tested on Dataset A and Dataset B respectively. "Avg" simply denotes the arithmetic average of the results from Task A and Task B. Model A(B) indicates a model that has been trained only on Dataset A(B). More specific parameter settings are provided in subsection B.2.

Analysis Our main experimental results are presented in Table 1. The data in these tables represent accuracy rates, and the standard deviations of the data are calculated based on five consolidation operations after a single model training session. Both the Git Re-Basin(^1^11https://github.com/samuela/git-re-basin) method and the Zipit(^2^22https://github.com/gstoica27/ZipIt) method utilize officially released codes for model fusion. Observing these results, we can find there is a significant improvement in joint accuracy using AutoFusion. When evaluating the Fused CNN model on the MNIST dataset, AutoFusion surpassed Zipit, the previously most advanced model, achieving a 13.23% improvement in joint accuracy. And for the Fused MLP Model, AutoFusion almost outperformed Zipit’s results by 34.6%. Correspondingly, the AutoFusion method has been greatly improved on both Task A and Task B. The results on CIFAR-10 show that although the improvement on this dataset is not as large as that of the MINIST dataset, it still maintains the SOTA in joint accuracy.

### 4.2 Ablation Study And Optimization Strategies

**Table 2: Different optimization strategies and ablation study.**
| Model | Method | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| CNN | Model A | $57.11\pm 0.01$ | $97.85\pm 0.01$ | $10.39\pm 0.01$ | $54.12$ |
| Model B | $54.35\pm 0.01$ | $17.24\pm 0.01$ | $98.86\pm 0.01$ | $58.05$ |  |
| Weight Interpolation | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |  |
| Weighted Optimize | $61.12\pm 1.1$ | $51.51\pm 0.8$ | $71.01\pm 0.9$ | $61.26$ |  |
| Rounded Optimize | $62.33\pm 0.1$ | $52.90\pm 1.8$ | $72.15\pm 1.2$ | $62.53$ |  |
| Normalized Optimize | $\mathbf{65.23}\pm 0.2$ | $\mathbf{58.65}\pm 0.3$ | $\mathbf{72.58}\pm 0.2$ | $\mathbf{65.62}$ |  |
| $\mathcal{L}_{align}$ Only | $36.00\pm 1.3$ | $21.58\pm 2.9$ | $50.85\pm 2.0$ | $36.22$ |  |
| $\mathcal{L}_{retain}$ Only | $60.98\pm 1.3$ | $53.92\pm 1.2$ | $68.25\pm 1.2$ | $61.08$ |  |
| MLP | Model A | $58.71\pm 0.01$ | $96.57\pm 0.01$ | $19.71\pm 0.01$ | $58.14$ |
| Model B | $52.86\pm 0.01$ | $9.89\pm 0.01$ | $97.12\pm 0.01$ | $53.51$ |  |
| Weight Interpolation | $33.76\pm 0.01$ | $40.08\pm 0.01$ | $27.24\pm 0.01$ | $33.66$ |  |
| Weighted Optimize | $82.10\pm 0.4$ | $86.12\pm 0.3$ | $77.95\pm 0.8$ | $82.04$ |  |
| Rounded Optimize | $83.03\pm 1.1$ | $83.55\pm 1.2$ | $82.51\pm 1.3$ | $83.03$ |  |
| Normalized Optimize | $\mathbf{85.85}\pm 0.7$ | $\mathbf{88.56}\pm 0.8$ | $\mathbf{83.04}\pm 0.8$ | $\mathbf{85.79}$ |  |
| $\mathcal{L}_{align}$ Only | $40.24\pm 0.05$ | $47.22\pm 0.1$ | $33.04\pm 0.02$ | $40.13$ |  |
| $\mathcal{L}_{retain}$ Only | $84.48\pm 1.2$ | $87.70\pm 0.6$ | $81.16\pm 0.5$ | $84.43$ |  |

Considering the two optimization objectives we have designed: $\mathcal{L}_{align}$ and $\mathcal{L}_{retain}$, the actual loss values computed for these two are not on the same scale. Therefore, if gradient descent is directly applied, the overall optimization direction will be dominated by the objective with the larger loss value, leading to failure in achieving our desired effects. To address this, we adopt and compare several common balancing methods in multi-task learning. Specifically, "Weighted Optimize" refers to balancing the two losses through manually set weights, which are set as $\omega_{a}=0.4$ and $\omega_{r}=0.6$ in our experiments. "Rounded Optimize" means alternately optimizing one of the two losses in different epochs to mitigate the mutual influence during the optimization of the two losses; in this case, we alternate every epoch. As for "Normalized Optimize", it indicates normalizing each loss value using its own value after each loss calculation, i.e., setting $\omega_{a}=\frac{1}{\parallel\mathcal{L}_{align}\parallel}$ and $\omega_{r}=\frac{1}{\parallel\mathcal{L}_{retain}\parallel}$, so that each loss is normalized to a unified scale for better convergence. Meanwhile, to demonstrate the necessity of combining and optimizing both align and retain losses, we also independently tested the two optimization objectives($\mathcal{L}_{align}$ Only and $\mathcal{L}_{retain}$ Only).

The representative experimental results can be derived from Table 2(More detailed parametric experiments are provided in Appendix C), which indicates that the Normalized Optimize method achieved the best performance, whereas directly applying the weighted method or the rounded optimization approach failed to yield better outcomes. Additionally, optimizing using only one component of the objective function did not attain the optimal results achieved through joint optimization. This, to some extent, demonstrates that the mutual constraints (or adversarial) between the two distinct optimization objectives can facilitate learning more valuable permutations. It is noteworthy that using only $\mathcal{L}_{retain}$ yielded decent results, suggesting that valuable permutations can be learned directly from the data; however, the best performance was attained only through the constraints imposed by $\mathcal{L}_{align}$.

### 4.3 Fusion of Task Models with Different Distributions

**Table 3: Fusion of different distribution models.**
| Fusion Method | Fused Model | MNIST | Fashion | KMNIST | Avg |
| --- | --- | --- | --- | --- | --- |
| Naive | MNIST | $95.58\pm 0.01$ | $9.81\pm 0.01$ | $9.70\pm 0.01$ | $38.36$ |
| Fashion | $13.25\pm 0.01$ | $96.78\pm 0.01$ | $8.82\pm 0.01$ | $39.61$ |  |
| KMNIST | $3.40\pm 0.01$ | $18.84\pm 0.01$ | $99.27\pm 0.01$ | $40.50$ |  |
| Weight<br>Interpolation | MNIST + Fashion | $11.66\pm 0.01$ | $59.43\pm 0.01$ | $9.48\pm 0.01$ | $26.85$ |
| MNIST+KMNIST | $9.65\pm 0.01$ | $15.09\pm 0.01$ | $60.27\pm 0.01$ | $28.34$ |  |
| KMNIST+Fashion | $9.04\pm 0.01$ | $12.09\pm 0.01$ | $14.04\pm 0.01$ | $11.72$ |  |
|  | Fused ALL | $9.40\pm 0.01$ | $10.05\pm 0.01$ | $9.66\pm 0.01$ | $9.70$ |
| AutoFusion | MNIST + Fashion | $66.40\pm 0.9$ | $\mathbf{86.20}\pm 0.8$ | $8.32\pm 0.6$ | $53.64$ |
| MNIST+KMNIST | $72.19\pm 1.1$ | $17.85\pm 1.3$ | $\mathbf{93.44}\pm 2.1$ | $61.16$ |  |
| KMNIST+Fashion | $6.71\pm 1.8$ | $80.58\pm 1.0$ | $88.83\pm 1.3$ | $58.70$ |  |
| Fused ALL | $\mathbf{86.99}\pm 2.4$ | $73.84\pm 3.3$ | $67.09\pm 2.8$ | $\mathbf{75.97}$ |  |

Figure: Figure 3: The interpolation test of each model on task A and task B after parameter fusion is carried out through the permutation matrices learned from different optimization objectives.
Refer to caption: x3.png

To further test the potential of AutoFusion, we proposed a more challenging experimental setup. In previous experiments, Task A and Task B were both from the same distribution. However, in this experiment, we chose datasets with completely different source distributions to test the ability of AutoFusion to fuse multi-task models trained on different distribution datasets. We selected MNIST [], Fashion-MNIST (referred to as Fashion) [], and KMNIST [] datasets. After independently training models on these three datasets, we tested the performance of pairwise fusion models and the fusion of all three models together. The experimental results are shown in Table 3
It is evident that after fusing the three models together, AutoFusion achieved an average accuracy of 75.97% across the three datasets, which is approximately 65% higher than the baseline Weight Interpolation method. Additionally, AutoFusion achieved good results in pairwise model fusion. Particularly, after fusing the three models, the performance on the MNIST dataset was higher than any pairwise fusion models, indicating that the fusion process enabled the model to extract features better suited for the MNIST dataset. This once again demonstrates that the AutoFusion method learns meaningful parameter permutations. The specific experimental setup is provided in subsection B.4.

### 4.4 Visualization

In this section, we provide some visualizations of the results to facilitate a more comprehensive understanding of our method. Here we only show the visualization results of the linear interpolation experiment to fully demonstrate the stability and superiority of the AutoFusion method under all interpolation coefficients, more visualizations are given in Appendix D.

Figure: Figure 4: The interpolation test on the joint dataset.
Refer to caption: x4.png

Linear Interpolation: Interpolating the parameters of two models to be fused using different interpolation parameters($\gamma\in[0,1]$) and evaluating the interpolated fusion model on a test set can observe the loss barriers between the two models [] [] []. In this work, we extend this visualization method to multi-task evaluation (subsection B.5 for detailed settings). For two models trained on different tasks, we set up three visualization perspectives. Two of them are the accuracies of the interpolated models, obtained through different interpolation parameters, on the test sets of Task A and Task B Figure 6, respectively. The third one is the test accuracy of the interpolated model on a complete dataset integrating both Task A and Task B Figure 4. It can be observed that when considering Task A and Task B separately, AutoFusion with Normalized has a higher accuracy rate than other settings. More strikingly, when tested on the integrated multi-task dataset, AutoFusion with Normalized shows a sharp contrast to the direct parameter interpolation method. When the interpolation parameter is around $0.6$, the accuracy of the direct interpolation method reaches its lowest point, while the accuracy of our method peaks, with a difference in accuracy exceeding $50\%$. This strongly demonstrates that our method can effectively fuse two models trained on different tasks using learnable permutations, enabling the fused model to exhibit promising performance in multi-task completion.

## 5 Limitation

Currently, most research on parameter fusion testing remains confined to simple models and datasets, and this paper is no exception. Existing methods have yet to yield significant results on complex datasets. Furthermore, because the automated fusion proposed by AutoFusion cannot be completely detached from data, we had to sample some training data to learn the permutation matrix. In the future, it may be possible to guide model fusion through fixed sets of data, but such endeavors will have to be left to future researchers.

## 6 Conclusion

This paper proposes a method named AutoFusion, which can learn a permutation matrix using only a few input samples. This permutation matrix effectively merges the parameters of two models designed for distinct tasks, resulting in a fused model capable of handling multiple tasks while maximizing accuracy across those tasks. AutoFusion can be regarded as the first work to apply an end-to-end approach in the field of multi-task parameter fusion. It significantly overcomes the bottleneck of previous works that heavily relied on prior knowledge and provides a valuable paradigm for the subsequent development of multi-task parameter fusion.

## 7 Acknowledgement

This work was supported by Guangzhou-HKUST(GZ) Joint Funding Program(Grant No.2023A03J0008), Education Bureau of Guangzhou Municipality.

## Appendix A Theoretical Analysis about Sinkhorn

The use of the Sinkhorn operator in our AutoFusion method is grounded in its ability to approximate the discrete permutation problem in a continuous, differentiable manner. This section presents a theoretical analysis to justify its adoption and establish error bounds for the approximation.

### A.1 Approximation Error Analysis

Consider the discrete permutation matrix $P^{*}$ that maximizes the inner product with the matrix $X$ subject to the entropy regularization. The Sinkhorn operator, $S_{\tau}(X)$, provides a continuous relaxation of this problem. We aim to bound the error between the discrete optimal permutation matrix $P^{*}$ and the soft permutation matrix $S_{\tau}(X)$ obtained from the Sinkhorn operator.

Let $\mathcal{E}$ denote the approximation error:

$$ $\mathcal{E}=\langle P^{*}-S_{\tau}(X),X\rangle_{F}$ (23) $$

where $\langle\cdot,\cdot\rangle_{F}$ is the Frobenius inner product.

Theorem (Error Bound for the Sinkhorn Operator): For any fixed $\tau>0$, the approximation error $\mathcal{E}$ satisfies the following inequality:

$$ $\mathcal{E}\leq\frac{\|X\|_{\infty}^{2}}{2\tau}$ (24) $$

Proof: We begin by observing that the Sinkhorn operator can be expressed as a fixed point iteration:

$$ $S_{\tau}(X)=\lim_{t\to\infty}S^{(t)}_{\tau}(X)$ (25) $$

where $S^{(t)}_{\tau}(X)$ is the $t$-th iteration of the soft Sinkhorn operator as defined in Equation 13.

The entropy-regularized optimal transport problem can be rewritten as a fixed point problem:

$$ $P^{*}=\mathcal{T}_{c}(\mathcal{T}_{r}(P^{*}\exp(X/\tau)))$ (26) $$

By the triangle inequality, we have:

$$ $\mathcal{E}\leq\langle P^{*}-S^{(t)}_{\tau}(X),X\rangle_{F}+\langle S^{(t)}_{ \tau}(X)-S^{(t+1)}_{\tau}(X),X\rangle_{F}$ (27) $$

The second term can be bounded using the update rule of the Sinkhorn operator:

$$ $\langle S^{(t)}_{\tau}(X)-S^{(t+1)}_{\tau}(X),X\rangle_{F}\leq\frac{\|X\|_{ \infty}^{2}}{2\tau}$ (28) $$

Taking the limit as $t\to\infty$, we obtain the desired error bound.

This theorem establishes that the approximation error is upper-bounded by a quantity that depends on the matrix norm $\|X\|_{\infty}$ and the regularization parameter $\tau$. As $\tau$ increases, the error bound becomes tighter, indicating that the soft permutation matrix approaches the optimal discrete permutation matrix.

### A.2 Differentiability and Gradient Flow

Proposition (Differentiability of the Sinkhorn Operator): The Sinkhorn operator $S^{(t)}_{\tau}(X)$ is differentiable with respect to $X$ for all $t\geq 0$, and its derivative can be expressed as:

$$ $\frac{\partial S^{(t)}_{\tau}(X)}{\partial X}=\frac{\partial S^{(t)}_{\tau}(X) }{\partial P^{(t)}}\frac{\partial P^{(t)}}{\partial X}$ (29) $$

where $\frac{\partial S^{(t)}_{\tau}(X)}{\partial P^{(t)}}$ is the Jacobian of the Sinkhorn operator with respect to the intermediate iterate $P^{(t)}$, and $\frac{\partial P^{(t)}}{\partial X}$ is the derivative of the intermediate iterate with respect to $X$.

The proof follows from the chain rule and the differentiability of the row and column normalization operations.

## Appendix B Implementation Details

### B.1 Description of Datasets Used Above

MNIST The MNIST dataset comes from the National Institute of Standards and Technology (NIST) in the United States. The training set consists of handwritten digits from 250 different individuals, with 50% from high school students and 50% from employees of the Census Bureau. The test set also contains handwritten digits in the same proportions, but authors of the test set do not overlap with those of the training set. The MNIST dataset comprises a total of 70,000 images, with 60,000 images in the training set and 10,000 images in the test set. Each image is a 28x28 pixel grayscale image representing a handwritten digit from 0 to 9. The images have a black background represented by 0 and the white digits are represented by floating-point values between 0 and 1, where values closer to 1 indicate a whiter color.

CIFAR-10 The CIFAR-10 dataset consists of 60,000 samples, each of which is a 32x32 pixel RGB image (color image). Each RGB image is divided into three channels (R channel, G channel, B channel). These 60,000 samples are divided into 50,000 training samples and 10,000 test samples. CIFAR-10 contains 10 classes of objects, labeled from 0 to 9, representing airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.

Fashion-MNIST Fashion-MNIST is an image dataset that serves as a replacement for the MNIST handwritten digit dataset. It was provided by the research department of Zalando, a fashion technology company based in Germany. The dataset consists of 70,000 frontal images of 10 different categories of items. The size, format, and division of training and test sets in Fashion-MNIST are identical to the original MNIST dataset. The dataset is divided into 60,000 training samples and 10,000 test samples, with 28x28 grayscale images that can be directly used for training models designed for MNIST.

KMNIST KMNIST is derived from Japanese Hiragana and Katakana characters and is maintained and open-sourced by the ROIS-DS Center for Open Data in the Humanities. The dataset consists of 70,000 high-resolution handwritten samples, with 10,000 samples per class, totaling 46 different character types. The purpose of KMNIST is to serve as a Japanese version of the MNIST dataset, used to evaluate the capabilities of machine learning and deep learning models in multi-language text recognition tasks.

For all datasets, we extracted 1000 images as a validation set for parameter tuning. These images were divided from the original training set and do not affect the test set.

### B.2 Details for Comparison Experiments

When independently training models on the divided datasets, we used the classic CNN and MLP architecture, for CNN, we used VGG to extract features and for MLP we designed 6 hidden layers to extract features. For simpler datasets like MNIST, we chose a smaller VGG model, while for more complex datasets like CIFAR-10, we used a deeper VGG to extract higher-level features. During training, the learning rate was set to $0.01$ for the MNIST dataset and $0.001$ for the CIFAR-10 dataset, with cross-entropy loss used as the training objective. When applying the method in subsection 3.1 to perform a differentiable approximation of the Sinkhorn operator, we found that using a limited number of iterations could achieve good approximation results. Therefore, we set the iteration coefficient $t=20$ when training the permutation matrix. For the data needed to train the matrix, we randomly sampled $2000$ input examples from the MNIST dataset and $2000$ input examples from the CIFAR-10 dataset. When selecting pseudo-labels, we set the filtering threshold $\zeta=0.9$ to filter out samples with lower confidence. Regarding the choice of combination weights for $\mathcal{L}_{align}$ and $\mathcal{L}_{retain}$ losses, due to the different magnitudes of the two losses, their impacts on parameter gradients were different. We ultimately adopted the commonly used technique in multi-task training to normalize the losses, scaling them to around $1$, to achieve more stable optimization results.

### B.3 Details for Ablation Study

We conducted evaluations on two architectures, CNN(VGG) and MLP, using the MNIST dataset. For the "Weighted Optimize" test, to avoid over-tuning and overfitting the model to the test set, we empirically chose the values $\omega_{a}=0.5$ and $\omega_{r}=0.5$. We then learned the parameter permutation matrix under these parameters, performed parameter fusion, and evaluated the final results. For the "Rounded Optimize" test, we employed a method of switching optimization objectives at each epoch. During the optimization matrix learning process, the learning rate was initially set to 1 and then decreased to 0.01 using a cosine annealing scheduler after 64 rounds to achieve convergence.

### B.4 Details for Multi-Task Fusion

In conducting non-identically distributed multi-task fusion, we conducted two experiments. The first experiment involved fusing models trained on two datasets. Apart from differences in data sources and the number of classes, the fusion steps in this experiment were the same as those in the comparison experiment, with no further elaboration. The second experiment involved fusing models trained on three datasets. Due to the limitations of the AutoFusion method, which can only learn one permutation matrix and fuse one model at a time, we first fused two models, saved the fused parameters, and then learned the permutation of the third model to better fuse with the saved parameters. This resulted in a fused model of three models. In this experiment, we prioritized fusing the models trained on MNIST and Fashion-MNIST, then learned the permutation of KMNIST to fuse it with the parameters obtained from the fusion of the first two models. Training the final permutation required accessing partial training sets from all three models. In this study, we sampled 10% of each training set to ensure the effectiveness of multi-task fusion. By following this approach, the AutoFusion method can actually fuse more model parameters.

### B.5 Details for Linear Interpolation

To better demonstrate the differences between different optimization strategies in linear interpolation, as well as the overall effectiveness of the AutoFusion method in the entire interpolation space, we selected the relatively simple MNIST dataset and the CNN (VGG) architecture. When training the permutation matrix, we used randomly sampled 1000 samples along with their true labels, with a sampling seed set at 3315. After learning the permutation matrix using different methods, we uniformly sampled 50 points in the range $[0,1]$. These points were used as values for $\gamma$ in turn, and models were fused using linear interpolation method. The final results were obtained on various test sets.

## Appendix C More Experiments

### C.1 Parametric Experiments On Pseudo-label Selection Threshold

To thoroughly validate the impact of pseudo-label threshold selection on the final results when conducting unsupervised permutation matrix learning, we conducted a fusion experiment using the AutoFusion method on the CNN (VGG) model on the MNIST dataset. Apart from the pseudo-label threshold, all other parameter settings were consistent with those of subsection B.2. The results are shown in Table 4

We still divide the 10-class MNIST dataset into two five-class datasets, represented as Dataset A and Dataset B respectively. In the experimental results, Task A represents the accuracy tested on Dataset A, while Task B represents the accuracy tested on Dataset B. Joint indicates the evaluation results on the complete dataset, while Avg represents the simple arithmetic average of Task A and Task B. The difference between "with Weighted" and "without Weighted" in the table lies in whether layer-wise weighting is applied when calculating $\mathcal{L}_{align}$. It can be observed that as $\zeta$ increases, the overall trend of the AutoFusion method is a gradual increase in the accuracy of Joint, reflecting the significant impact of the pseudo-label threshold on the results, and indicating that this method can effectively filter out incorrect labels. By comparing the results of the AutoFusion method with and without layer-wise weighting, it can be seen that layer-wise weighted averaging performs better. The reason for this may be that the neurons in the shallow layers of neural networks generally learn more universal features, making them more suitable for alignment. Therefore, assigning greater weight to align the neurons in the shallow layers during weighting contributes to the learning of higher-quality alignment matrices.

**Table 4: The impact of different pseudo-label thresholds on the final result.**
| Method | $\zeta$ | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Interpolation | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion<br>with Weighted | $0.9$ | $65.53\pm 0.2$ | $58.47\pm 0.1$ | $72.79\pm 0.4$ | $65.63$ |
| $0.8$ | $64.61\pm 0.3$ | $57.39\pm 0.4$ | $72.04\pm 0.5$ | $64.72$ |  |
| $0.7$ | $65.88\pm 1.1$ | $60.13\pm 1.1$ | $71.80\pm 0.6$ | $65.96$ |  |
| $0.6$ | $64.18\pm 0.6$ | $56.58\pm 0.7$ | $72.00\pm 0.6$ | $64.29$ |  |
| $0.5$ | $63.59\pm 0.5$ | $57.58\pm 0.5$ | $69.77\pm 0.4$ | $63.68$ |  |
| $0.4$ | $63.26\pm 0.6$ | $55.97\pm 0.5$ | $70.77\pm 0.8$ | $63.37$ |  |
| $0.3$ | $64.72\pm 0.4$ | $59.18\pm 0.3$ | $70.42\pm 0.5$ | $64.80$ |  |
| $0.2$ | $64.42\pm 0.7$ | $57.04\pm 0.9$ | $72.03\pm 0.8$ | $64.54$ |  |
| $0.1$ | $63.72\pm 1.1$ | $55.40\pm 1.2$ | $72.28\pm 0.7$ | $63.84$ |  |
| AutoFusion<br>without Weighted | $0.9$ | $65.28\pm 0.3$ | $59.91\pm 0.4$ | $70.81\pm 0.5$ | $65.36$ |
| $0.8$ | $61.66\pm 0.3$ | $53.07\pm 0.3$ | $70.50\pm 0.3$ | $65.36$ |  |
| $0.7$ | $60.54\pm 0.4$ | $49.78\pm 0.7$ | $71.62\pm 0.5$ | $60.70$ |  |
| $0.6$ | $62.55\pm 0.5$ | $57.56\pm 0.7$ | $67.68\pm 0.3$ | $62.62$ |  |
| $0.5$ | $61.43\pm 0.4$ | $53.98\pm 0.4$ | $69.10\pm 0.5$ | $61.54$ |  |
| $0.4$ | $63.86\pm 1.2$ | $55.47\pm 0.9$ | $72.49\pm 1.9$ | $63.98$ |  |
| $0.3$ | $60.42\pm 0.6$ | $53.68\pm 0.7$ | $67.35\pm 1.2$ | $60.52$ |  |
| $0.2$ | $61.87\pm 0.8$ | $52.40\pm 0.6$ | $71.61\pm 1.3$ | $62.01$ |  |
| $0.1$ | $59.62\pm 0.6$ | $52.96\pm 0.3$ | $66.48\pm 0.9$ | $59.72$ |  |

### C.2 Parametric Experiments On Weighted Optimize

In this experiment, we primarily investigated the optimization of alignment matrices by directly weighting two loss functions ($\mathcal{L}_{align}$ and $\mathcal{L}_{retain}$). We continued to utilize the CNN (VGG) architecture model and the MNIST dataset, with the same data partitioning method and parameter settings as subsection B.2. In this study, our focus was solely on analyzing the performance of the fused model when different weights were applied to the loss functions. As can be seen from Table 5, it is evident that with varying weighting methods, the values of Joint only fluctuated within a certain range, indicating the model’s stability with respect to this parameter. All results outperformed Weight Interpolation by approximately 40% in terms of accuracy, further emphasizing the stability of the AutoFusion method.

**Table 5: Different Weight Setting for Weighted Optimize Strategies.**
| Method | Weights | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Interpolation | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion | $\omega_{a}=0.1,\omega_{r}=0.9$ | $64.09\pm 1.6$ | $57.68\pm 0.8$ | $70.68\pm 1.2$ | $64.18$ |
| $\omega_{a}=0.2,\omega_{r}=0.8$ | $63.91\pm 0.8$ | $54.33\pm 0.9$ | $73.77\pm 1.2$ | $64.05$ |  |
| $\omega_{a}=0.3,\omega_{r}=0.7$ | $63.94\pm 0.6$ | $55.16\pm 0.5$ | $72.98\pm 0.9$ | $64.07$ |  |
| $\omega_{a}=0.4,\omega_{r}=0.6$ | $61.27\pm 1.2$ | $52.93\pm 0.8$ | $69.85\pm 0.7$ | $61.39$ |  |
| $\omega_{a}=0.5,\omega_{r}=0.5$ | $61.12\pm 1.1$ | $51.51\pm 0.8$ | $71.01\pm 0.9$ | $61.26$ |  |
| $\omega_{a}=0.6,\omega_{r}=0.4$ | $60.12\pm 0.6$ | $50.82\pm 0.5$ | $69.69\pm 0.6$ | $60.26$ |  |
| $\omega_{a}=0.7,\omega_{r}=0.3$ | $62.79\pm 0.4$ | $53.94\pm 0.8$ | $71.90\pm 1.2$ | $62.92$ |  |
| $\omega_{a}=0.8,\omega_{r}=0.2$ | $64.49\pm 1.3$ | $57.67\pm 0.8$ | $71.51\pm 1.5$ | $64.59$ |  |
| $\omega_{a}=0.9,\omega_{r}=0.1$ | $63.21\pm 0.3$ | $56.52\pm 0.4$ | $70.09\pm 0.5$ | $63.31$ |  |

### C.3 Parametric Experiments On Rounded Optimize

In this experiment, we investigated the impact of optimizing different loss functions on the AutoFusion method based on epochs. Specifically, we optimized either $\mathcal{L}_{align}$ or $\mathcal{L}_{retain}$ during a single backpropagation, switching the optimization target every n epochs. The experiment utilized the CNN (VGG) network on the MNIST dataset, with the same data partitioning method and parameter settings as subsection B.2. We tested the performance of AutoFusion with different switching cycles (i.e., switching optimization targets at different epoch intervals). The experimental results, as shown in Table 6, revealed that the optimal result of 65.19% accuracy was achieved when the epoch was set to 5. However, the performance of AutoFusion did not vary significantly with changes in the epoch interval. Nonetheless, it consistently outperformed the Weight Interpolation method by a significant margin, demonstrating the stability of AutoFusion in response to parameter variations.

**Table 6: Different Epoch Setting for Rounded Optimize Strategies.**
| Method | Epochs | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Avg | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion | $epoch=1$ | $62.36\pm 1.2$ | $53.88\pm 1.1$ | $71.09\pm 1.3$ | $62.48$ |
| $epoch=2$ | $62.11\pm 0.6$ | $54.55\pm 0.7$ | $69.89\pm 1.1$ | $62.22$ |  |
| $epoch=3$ | $63.08\pm 0.8$ | $55.32\pm 0.4$ | $71.07\pm 0.7$ | $63.19$ |  |
| $epoch=4$ | $64.78\pm 0.4$ | $55.38\pm 0.2$ | $74.46\pm 0.6$ | $64.92$ |  |
| $epoch=5$ | $65.19\pm 0.4$ | $58.98\pm 0.3$ | $71.57\pm 0.3$ | $65.27$ |  |
| $epoch=6$ | $62.12\pm 1.2$ | $52.71\pm 0.7$ | $71.80\pm 1.1$ | $62.26$ |  |
| $epoch=7$ | $61.99\pm 1.1$ | $54.78\pm 0.3$ | $69.40\pm 0.9$ | $62.09$ |  |
| $epoch=8$ | $61.07\pm 1.7$ | $49.70\pm 2.2$ | $72.77\pm 1.2$ | $61.24$ |  |

### C.4 Number of Step to Approximate the Sinkhorn Operator

Although we provided an upper bound on the error of approximating the sinkhorn operator using an iterative approach in the paper, it is still essential to explore the impact of the approximation steps on the results in experiments. In this experiment, we set different numbers of iteration steps and recorded the performance of the AutoFusion method at the corresponding iteration steps. We continued to use the CNN (VGG) network as the feature extraction network and selected the MNIST dataset, keeping the settings of other parameters and data partitioning method consistent with subsection B.2, with the only variation being the number of iteration steps. The experimental results, as shown in Table 7, indicate that when the number of iterations is generally large, the accuracy of AutoFusion on Joint is relatively high. However, when the number of iterations exceeds 20, the accuracy of Joint does not show significant improvement with an increase in the number of iterations. In fact, the accuracy of Joint may even decrease due to the impact of the iteration steps on convergence speed.

**Table 7: Different Step to Approximate the Sinkhorn Operator.**
| Method | Iteration | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Avg | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion | $iter=5$ | $61.29\pm 1.4$ | $52.13\pm 1.3$ | $70.72\pm 1.1$ | $61.43$ |
| $iter=10$ | $63.41\pm 1.0$ | $56.97\pm 0.9$ | $70.03\pm 1.2$ | $63.50$ |  |
| $iter=15$ | $64.04\pm 0.5$ | $57.23\pm 0.3$ | $71.05\pm 1.1$ | $64.14$ |  |
| $iter=20$ | $65.62\pm 0.6$ | $58.47\pm 0.2$ | $72.79\pm 1.3$ | $65.63$ |  |
| $iter=25$ | $64.50\pm 0.4$ | $57.92\pm 0.3$ | $71.27\pm 0.9$ | $64.59$ |  |
| $iter=30$ | $64.98\pm 0.3$ | $56.36\pm 0.2$ | $73.85\pm 1.2$ | $65.10$ |  |
| $iter=35$ | $63.77\pm 0.5$ | $55.06\pm 0.5$ | $72.73\pm 0.8$ | $63.99$ |  |
| $iter=40$ | $62.63\pm 0.4$ | $54.69\pm 0.3$ | $70.80\pm 1.2$ | $62.75$ |  |

### C.5 Training Permutation Matrices at different data usage ratios using real labels

In order to fully explore the potential of the AutoFusion method, we attempted to train parameter alignment matrices using real data labels and tested the relationship between the size of the training data and the performance of the fusion model. In this experiment, we utilized the CNN (VGG) architecture on the MNIST dataset. We initially extracted 9000 images from MNIST as the complete dataset, where the "Part" column in the table represents the proportion of the complete dataset used. All data had access to real labels. The experimental results in Table 8 clearly demonstrate that compared to previous experiments without access to real data labels, training with real labels resulted in better alignment matrix learning. With only 10% of real data, the Joint accuracy of the fusion model reached 73.06%. As the proportion of data increased, the Joint accuracy peaked at 83.21%. This indicates that the hypothesis proposed by the AutoFusion method, which suggests that learning parameter alignments can facilitate multi-task parameter fusion, is correct. It also suggests that there exists an opportunity in the future to approximate the optimal alignment matrix through more advanced algorithm designs. An interesting observation in the experimental results is that when the proportion of data used exceeded 40%, there was not a significant increase in Joint accuracy. This further highlights that AutoFusion operates within a limited search space and can yield valuable solutions even when using a small portion of the data.

**Table 8: The impact of using different proportions of data on the effect of fusion.**
| Method | Part | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Interpolation | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion | $10\%$ | $73.06\pm 1.1$ | $66.81\pm 0.9$ | $79.49\pm 1.2$ | $73.15$ |
| $20\%$ | $77.39\pm 0.4$ | $71.95\pm 0.3$ | $82.98\pm 0.6$ | $77.47$ |  |
| $30\%$ | $77.79\pm 0.3$ | $73.17\pm 0.3$ | $82.54\pm 0.4$ | $77.86$ |  |
| $40\%$ | $82.55\pm 0.7$ | $75.40\pm 0.6$ | $89.91\pm 0.9$ | $82.66$ |  |
| $50\%$ | $79.29\pm 0.5$ | $74.77\pm 0.2$ | $83.94\pm 0.7$ | $79.36$ |  |
| $60\%$ | $80.23\pm 1.2$ | $73.52\pm 0.3$ | $87.21\pm 0.8$ | $80.37$ |  |
| $70\%$ | $81.19\pm 0.3$ | $73.66\pm 0.4$ | $89.70\pm 0.3$ | $81.68$ |  |
| $80\%$ | $82.88\pm 1.2$ | $78.12\pm 0.9$ | $87.77\pm 0.9$ | $82.95$ |  |
| $90\%$ | $81.33\pm 0.9$ | $76.19\pm 0.3$ | $86.62\pm 0.8$ | $81.41$ |  |
| $100\%$ | $83.21\pm 0.4$ | $78.24\pm 0.3$ | $88.10\pm 0.5$ | $83.17$ |  |

### C.6 An exploration of the relationship between model depth and fusion effects

We also explored how the fusion model’s capabilities using the AutoFusion method changed as the depth of the model gradually increased. In the following experiment Table 9, we selected the relatively simple but significantly effective MLP architecture as the feature extraction network, with the MNIST dataset still being utilized. The only variable in this experiment was the number of hidden layers in the MLP. Each hidden layer was a non-linear mapping layer ranging from 512 to 512. We set the number of these hidden layers to be 2, 4, 6, and 8. The initial model training process, data partitioning, and settings are consisted of subsection B.2. AutoFusion was used for parameter fusion at different depths as mentioned above. The experimental results indicate that as the number of hidden layers increased from 2 to 6, the accuracy of the Joint continued to improve. Since the original models of different depths had similar test results on the test set (ranging from 98% to 99%), the improvement in Joint accuracy after parameter fusion sufficiently demonstrates that AutoFusion has better fusion capabilities for deeper networks. However, when the number of hidden layers reached 8, we observed a slight decrease in Joint accuracy. This is likely due to the overfitting of the overly deep network to the MNIST dataset, which falls within the normal range of results.

**Table 9: The impact of using different proportions of data on the effect of fusion.**
| Method | Hidden Length | Joint | TaskA | TaskB | Avg |
| --- | --- | --- | --- | --- | --- |
| Model A | - | $58.65\pm 0.01$ | $98.77\pm 0.01$ | $17.31\pm 0.01$ | $58.03$ |
| Model B | - | $53.97\pm 0.01$ | $10.60\pm 0.01$ | $98.63\pm 0.01$ | $54.61$ |
| Weight Interpolation | - | $25.44\pm 0.01$ | $18.58\pm 0.01$ | $32.50\pm 0.01$ | $25.54$ |
| AutoFusion | $length=2$ | $82.21\pm 0.4$ | $89.59\pm 0.8$ | $74.60\pm 0.4$ | $82.09$ |
| $length=4$ | $83.53\pm 0.9$ | $88.45\pm 1.1$ | $78.46\pm 0.6$ | $83.46$ |  |
| $length=6$ | $85.12\pm 1.1$ | $82.99\pm 0.9$ | $87.31\pm 1.0$ | $85.15$ |  |
| $length=8$ | $79.23\pm 2.2$ | $70.89\pm 1.7$ | $87.81\pm 3.6$ | $79.35$ |  |

## Appendix D More Visualization

Figure: Figure 5: Export the trained permutation matrix and compare it with Git Re-Basin Method.
Refer to caption: x5.png

### D.1 Feature Extraction Capability of Fusion Models

Setting We conducted some visualizations of the activation maps in the intermediate layers of the multitask model trained on MNIST and the model after fusion, aiming to evaluate the effect of the fused model from a more intuitive perspective. As illustrated in Figure 6, the first column displays the input data. The second column shows the activation map for Model A in response to this input, and the third column presents the activation map for Model B corresponding to the same input (where Model A and Model B are models trained separately on divided datasets, with the specific division details and training methods referred to section 4). Meanwhile, the fourth column depicts the activation map for the output using the AutoFusion method to fuse Models A and B.

Analysis It is evident from the figure that, since Model A and Model B were trained only on subsets of the dataset, their ability to extract features is inferior for some inputs. However, the fused model (Fused) clearly demonstrates an improved capability to integrate the feature extraction abilities of different models, capturing key features for all inputs. This provides a more intuitive validation of the effectiveness of the AutoFusion parameter fusion algorithm.

Figure: Figure 6: Visualization of the ability of the model to capture features before and after fusion.
Refer to caption: x6.png

### D.2 Permutation Matrix

| Layer Index | Git Re-Basin | Ours |
| --- | --- | --- |
| Layer 1 | $64$ | $62$ |
| Layer 2 | $126$ | $128$ |
| Layer 3 | $1024$ | $1024$ |

We visualize the permutation matrices learned by the Git Re-Basin method and our method (only the first two layers) as shown in Figure 5. By observing the permutation matrix of the first layer, it can be found that our permutation matrix can learn more complex permutations to some extent, whereas the Git Re-Basin method in the first layer resembles direct linear interpolation. Starting from the second layer, we calculate the degree of permutation complexity using the $L1$ distance subsection D.2. It can be observed that, given similar levels of permutation complexity, our method achieves better results. This indirectly demonstrates that our method can learn more valuable permutation matrices.

### D.3 An Overview of CAMs

In this section, we provide additional visualizations of model activation maps on the MNIST/KMNIST datasets for reference, aiming to further understand the advantages of the actual fusion model and potential issues that may still exist. The arrangement of rows and columns is consistent with the subsection D.1, with results on the MNIST dataset illustrated in Figure 8, and those on the KMNIST dataset shown in Figure 9.

It’s particularly noteworthy that in these visualizations, we can observe that for some inputs, neither Model A nor Model B is capable of effectively extracting features. However, the model post-AutoFusion integration outperforms both pre-fusion models in terms of feature extraction. This further demonstrates that AutoFusion has learned a more valuable permutation.

Given that the core of the AutoFusion algorithm involves learning the permutation matrix of model parameters, this section provides visualizations of the permutation matrices learned by the AutoFusion algorithm when running on three datasets (MNIST, KMNIST, Fashion-MNIST). This offers a more visual display of the AutoFusion method, where the division method for each dataset and the model training process is consistent with section 4. As illustrated, since the CNN(VGG) model we utilized comprises four convolutional layers, our consideration for permutation also exclusively encompasses these four layers.

Figure: Figure 7: Visualization of permutation matrices.
Refer to caption: x7.png

Figure: Figure 8: CAMs visualization results on the MNIST dataset.
Refer to caption: extracted/5906482/mnist-full-3.png

Figure: Figure 9: CAMs visualization results on the KMNIST dataset.
Refer to caption: extracted/5906482/kmnist-full-3.png

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 4
questions: Please refer to weaknesses.
soundness: 3
strengths: Although I am not an expert in this domain, I believe these strengths should be acknowledged:

+ The paper presents a clear and convincing motivation, effectively setting the stage for the proposed work. 
+ There is a notable degree of innovation in the methodology, and the authors have thoroughly reviewed prior approaches, clarifying how their contributions advance the state-of-the-art. 
+ The results achieved by the proposed method are impressive, consistently outperforming baselines across a variety of experimental settings, which underscores its effectiveness. 
+ Additionally, the paper provides detailed theoretical proofs that reinforce the validity and soundness of the approach. 
+ The writing is also commendable, as the paper reads smoothly and is relatively accessible, making it easier for readers to grasp complex concepts. 

Overall, this work shows promise in advancing the field and could be a valuable addition to the literature.
summary: This paper concentrates on a very interesting problem: how to fuse two types of distinct model parameters pretrained for two different tasks into one model that can simultaneously solve two tasks. By applying permutation on different parameters and unsupervised  learning on unlabeld data, this paper provide an autofusion method and achieves good performance.
weaknesses: - Line 225: The sentence appears to be incomplete because it begins with a conditional clause (“If we attempt to…”), which typically requires a main clause to complete the thought. In English, when a sentence starts with “If,” it sets up an expectation that there will be a following statement explaining the result, purpose, or consequence of the condition.

- To further demonstrate the effectiveness of the proposed fusion method, more complex tasks and datasets should be considered, such as detection and segmentation tasks with VOC, COCO, or ImageNet datasets, respectively. In this paper, the evaluation is limited to the classification task on two relatively simple datasets (MNIST and CIFAR-10), which is insufficient to validate the robustness of the approach and may render the work less substantial. I will update my final score if the authors can provide more experimental results on some complex tasks and datasets.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 1
questions: please refer to items in weaknesses.
soundness: 2
strengths: - It leverages Mena et al. (2018) to make permutation matrix in Re-basin differentiable, thus allowing end-to-end training.
- It achieves clear improvement over baseline methods on MINST and CIFAR.
summary: This paper introduces AutoFusion, a framework that fuses distinct model’s parameters (with the same architecture) for multi-task learning. The key idea is to leverage Mena et al. (2018) to make permutation matrix in Re-basin differentiable, thus allowing end-to-end training. Experimental results demonstrate clear improvement over baseline methods.
weaknesses: __Experiments could be improved__

- an analysis of model similarity is needed.
- baselines of fine-tuning the model (trained on one task) on the multi-task jointly are needed. They will provide a good reference even though they are not consider as fair comparisons.
- LoRA fine-tuning could be considered as a fair baseline. As the proposed model learns a permutation matrix per layer, which essentially can be considered as low-rank fine-tuning. Thus, adding comparison to LoRA fine-tuning would provide additional insights.
- In section 4.3, it only compares to weight interpolation on different distributions. Please add comparisons to Git Re-Basin and Zipit (similar to section 4.1)
- experiments on larger dataset (like ImageNet) using transformer based architectures would provide more convincing evidences.

__The paper needs a major revision in writing.__

- The introduction could be improved. It is not usual to have half of the introduction to summarize contributions. It would be better to add more lines on the loss function and unsupervised setup and reduce the space for contributions.

- Figure 1 could be improved. Please adding explanation what each animal represents in the caption.

- Please avoid overusing equations. For example, eq. 1-4 could be in text for better readability. Eq. 7 and 8 could be combined. Eq. 9 and 10 need more explanation about M, U and insights behind. Eq. 11 could be in text.

- Figure 2 is too busy. Math equations make it difficult to read.

- Line 209: “in the absence of pre-trained parameters”. Are parameters in Model A and B pre-trained? This is confusing.

- Line 215: “However, this assumption of high similarity falls apart when the models to be merged are trained for different tasks.” Please demonstrate this by real examples and measure the similarities for different tasks.

- Section 3.1 could be written in a more straightforward manner. It simply leverages differentiable Sinkhorn operator in prior works Mena et al. (2018) and Pena et al. (2023). The error bound is nice to have, but not directly related to the key idea of the paper.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 1
questions: 1. For models trained independently rather than fine-tuning from a shared pre-trained checkpoint, the task-specific models reside in different loss basins. Consequently, linear weight interpolation is expected to yield the worst performance in this scenario. Nonetheless, in Table 4.1, for MLP models on two disjoint MNIST subsets, weight interpolation surpasses both Git Re-Basin and ZipIt. Could the authors please provide an explanation for this?
2. Can the proposed method scale to larger models such as vision transformers used in [1]?

[1] Kinderman et al. Foldable SuperNets: Scalable Merging of Transformers with Different Initializations and Tasks. http://arxiv.org/abs/2410.01483
soundness: 3
strengths: 1. The visualization of the method is good.
2. The application of the Sinkhorn operator is innovative in the field of deep model fusion.
summary: In this work, the authors aim to merge models independently trained with different initializations. Specifically, the authors employ the Sinkhorn operator to convert the problem of finding a discrete permutation matrix into a differentiable problem that can be directly optimized using gradient descent algorithms.
weaknesses: 1. It would be beneficial to list the number of optimized parameters of each methods.
2. Lacking related work or experimental results to substantiate the claim in lines 215-218 that "However, this assumption of high similarity falls apart when the models to be merged are trained for different tasks. During merging, we must not only align parameters with similar functions but also strive to retain parameters with distinct functions, enabling the fused model to perform various tasks simultaneously."
3. The manuscript lacks a related work section. The introduction is insufficient and fails to provide a comprehensive overview of the existing literature and context for the study. The author could further discuss why the absence of a shared pre-trained initialization poses a challenge to multi-task model merging.
4. It would be beneficial to compare the results of the model merging techniques with the ensemble method and knowledge distillation method, as demonstrated in [1].
5. In lines 351-353, Git Re-Basin archives the best results for Task B, while AutoFusion is highlighted.

[1] Kinderman et al. Foldable SuperNets: Scalable Merging of Transformers with Different Initializations and Tasks. http://arxiv.org/abs/2410.01483

Meta-review: This paper presents an AutoFusion method for fusing parameters from distinct models for multi-task learning without relying on pre-trained checkpoints. It dynamically permutes model parameters at each layer, optimizing their combination through an unsupervised process.

This paper received mixed reviews, with one positive and two negative scores. All reviewers agree that the current evaluation is insufficient to support the proposed method. Additionally, the results seen in the added experiments, such as VOC object detection, lack sufficient convincing evidence. More comprehensive experiments are needed to strengthen the claims. At this stage, the paper is not sufficiently prepared for publication.

Decision: Reject