HM3: Hierarchical Multi-Objective Model Merging for Pretrained Models

W1: Thank you for your attention to the time cost analysis. We acknowledge that the original manuscript lacked sufficient detail regarding computational overhead. This omission was primarily due to our view that architecture-level model merging is fundamentally a different task from most existing parameter-level merging methods. The former involves dynamically altering the inference path via search, which inevitably introduces a larger search space and higher computational complexity. However, we believe the necessity of exploring more optimal model compositions beyond fixed architectures should not be overlooked. Therefore, despite the increased complexity, architecture merging constitutes a meaningful research direction that deserves investigation.

To address this concern, we have included two additional architecture-level baselines under the same maximum inference path length T_{\max} for comparison:

• Grid Search: Exhaustively enumerates possible paths using Mergekit’s passthrough for layer composition until a similar number of evaluations as HM3 is reached.
• Evolutionary Search: Uses differential evolution with standard settings and Mergekit’s passthrough for layer composition, matching HM3's evaluation budget. This differs from the EA baseline in the original submission, which restricted the search space via token constraints but at the cost of final merged model performance.

The performance comparison is shown below:

These results confirm that HM3 consistently outperforms other search-based merging methods under equivalent computational budgets.

W2: As noted in W1, architecture-level merging differs fundamentally from parameter-level merging. While the latter operates on a fixed model topology by interpolating weights, architecture merging constructs new inference paths by combining layers from different pretrained models.

Our original baselines focused on representative parameter-level methods to highlight the benefits of architecture merging. However, we acknowledge that this may have limited the comprehensiveness of the evaluation.

To address this, we have included two SOTA parameter merging methods—PCB-Merging [1] and Consensus Merging [2]—as baselines, recommended in Reviewer TWdc. Results show that HM3 consistently outperforms on language ( see following additional experiment) and vision tasks (please see the result in Reviewer TWdc), reinforcing the effectiveness of HM3.

[1] PCB-Merging: Parameter Competition Balancing for Model Merging, NeurIPS 2024 [2] Consensus Merging: Localizing Task Information for Improved Model Merging and Compression, ICML 2024

Additional experiment

1.LLAMA-2-13B

2.LLAMA-2-7B

3.Qwen-2.5-1.5B

W3: Thank you for your valuable comments. We address your concerns in two parts:

Regarding Figure 2: The displayed Pareto front is not from a single run, but represents the mean performance across 10 independent runs, each using a different random seed for each preference vector. For each vector, we generate one merged model per run, evaluate it on the three tasks, and report the average performance over 10 runs. As a result, we obtain 15 averaged performance points corresponding to the 15 preference vectors (S1–S15). All baselines are also run with 10 different seeds for fair comparison. We will clarify this setup in the revised version.

Regarding Figure 6: We agree that the current figure lacks a depiction of variability. To improve it, we re-ran HM3 under the same preference vector for 10 independent trials. The standard deviation of final rewards is consistently below 0.6, confirming the robustness and reproducibility of our method. The updated figure in the revision will show the average reward curve with shaded confidence intervals across episodes to better illustrate convergence stability.

W4: Thank you for your constructive feedback on the value function formulation. While Eq. (13) is mathematically correct, we agree its original form may cause ambiguity.

To improve clarity, we revised it as:

$L^{\text{VF}}(\phi) = E_t$ (V\phi(S_t)-\hat{V_t})^2 $, \quad \hat{V_t} = V_\phi(S_t) + \hat{A_t}$

where $\hat A_t$ is the advantage estimated via generalized advantage estimation. This formulation clearly separates the value prediction $V_\phi(S_t)$ from the target $\hat V_t$, avoiding confusion with expressions like $V_\phi(S_t)-\hat A_t$.

We also include a detailed explanation of GAE in the appendix to support reproducibility and clarity.

W5: Thank you for your thoughtful suggestions regarding the feasibility and semantic consistency of cross-architecture layer stitching. We fully agree that maintaining representational alignment is critical when merging layers from heterogeneous models. Our MLP-based projection mechanism is specifically designed to address both dimensional and distributional mismatches.

We revised the manuscript to analyze this issue from three perspectives:

1. Theoretical and empirical motivation: We explicitly discuss challenges such as hidden size mismatches, differing attention head numbers, normalization statistics, and semantic drift, which are common even across structurally similar models. Prior work [3] also shows that naive layer stitching (e.g., CodeLLaMA vs. LLaMA-2-Chat) significantly degrades performance. Our appendix includes a moment-matching analysis to support how the projection matrix helps align feature distributions.

2. Empirical validation: We conducted ablation experiments using LLaMA-2-7B to assess the impact of omitting MLP alignment:

These results confirm that the projection mechanism substantially improves cross-layer semantic alignment and task performance.

3. Future directions: A new Discussion section in the revised manuscript highlights this issue and frames our work as an initial step toward principled cross-model layer composition. We hope it motivates further exploration of lightweight and theoretically grounded alignment strategies.

[3] Y. He, et al. MergeBench: A Benchmark for Merging Domain-Specialized LLMs. arXiv preprint arXiv:2505.10833, 2025.

W1: We thank the reviewer for the insightful suggestion. While our original focus was on classical baselines to emphasize HM3's joint parameter- and architecture-space merging capability, we acknowledge the importance of including recent SOTA methods. Accordingly, we have made the following updates:

1. Inclusion of PCB Merging: We re-implemented PCB Merging and evaluated it across all tasks, including text and vision. The results are included in the revised manuscript.

2. Consensus Merging as a substitute for CAT Merging: As CAT Merging was recently accepted to ICML 2025 and lacks public source code, we are working to reimplement it. Meanwhile, we added Consensus Merging [1], a strong baseline emphasized in the CAT Merging paper.

3. Empirical insights: PCB Merging initially outperformed the original HM3 due to its high-quality merged model. After incorporating PCB-generated models into HM3's candidate pool, HM3 significantly outperformed PCB, highlighting its flexibility and strength in architecture-level merging.

4. Updated related work: We revised the Related Work section to discuss PCB, CAT, and Consensus Merging, offering a more comprehensive literature review.

   [1] Wang et al., Localizing Task Information for Improved Model Merging and Compression, ICML, 2024.

Additional experiment

1. ViT-B/32

2. Vit-L/14

3.LLAMA-2-13B

4.LLAMA-2-7B

5.Qwen-2.5-1.5B

W2: We thank the reviewer for the valuable feedback. In original version, hyperparameters were tuned via grid search on smaller models and then transferred to larger ones. The revised manuscript includes further clarifications:

• Expanded hyperparameter details: We now list key hyperparameters (e.g., RL learning rate, Wolpertinger neighborhood size, number of subproblems) with value ranges. These were tuned on Qwen‑1.5B and ViT‑B/32, then applied to LLaMA‑2‑7B and ViT‑L/14. Further experiments are ongoing and results will be provided for the final version.
• Updated related work: We added Model Evolver and GENOME to our review. Both use evolutionary method to merge weights in fixed architectures and need to restart for each task.
• Comparison with HM3: Unlike the above, HM3 incorporates RL for architecture-level search, supports cross-model layer stitching, and adopts multi-objective scalarization for diverse solutions. The learned policy generalizes across tasks and model pools, enhancing reuse and efficiency. We also discuss potential combinations of evolutionary search and RL to further improve joint merging capabilities.

W3: We thank the reviewer for emphasizing the importance of generalization. Our original evaluation covered three core LLM task domains, math reasoning, code generation, and multilingual translation, following the Qwen-3 evaluation protocol (e.g., Table 3 in the Qwen-3 technique report). To strengthen generalization, we have expanded both task and model coverage:

Expanded Task domain: Added GLUE benchmark for generative task domain.

Expanded Tasks:

• Multilingual (Translation): Added XNLI dataset.
• Math: Added MathQA dataset.
• Code: Added MBPP dataset.

Expanded Models:

• Added LLaMA-2-13B and fine-tuned variants.

These enhancements further demonstrate the robustness and broad applicability of our method across tasks and model sizes.

Q1: We thank the reviewer for the insightful feedback and respond from two angles: model compatibility and task generalization.

Model Compatibility: HM3 effectively merges models with identical architectures but different specializations. Notably, HM3 also supports architecture-level merges, unlike standard parameter merging, allowing flexible architectural extensions. This capability draws inspiration from SOLAR‑10.7B [2], which significantly improved performance by concatenating the first 20 layers and last 20 layers of Mixtral‑7B followed by continued pretraining. HM3 aims to achieve similar architecture expansion in a training-free manner through model merging, without the need for expensive retraining.

However, merging models with fundamentally different architectures (e.g., Qwen vs. LLaMA) remains difficult. Severe mismatches in dimensions and representations can significantly degrade performance. Our MLP alignment mitigates shallow-level discrepancies but cannot fully bridge deeper semantic gaps. Without alignment, merged models fail even on simple benchmarks.

While HM3 does not yet support fully heterogeneous model merging, it serves as a promising step toward that goal. We will clarify these limitations and discuss future extensions in the revised version.

Task Generalization: We initially evaluated HM3 on math, code and translation task domains, following Qwen‑3's domain grouping. In the revised version, we expand coverage to include the General task domain and an additional task per existing task domain. Results confirm HM3's strong performance across diverse tasks, highlighting its generalization ability. [2] D. Kim et al., Solar 10.7B: Scaling Large Language Models with Simple Yet Effective Depth Up-Scaling, arXiv:2312.15166, 2023.

Q2: We thank the reviewer for emphasizing the importance of policy generalization. To evaluate reusability, we conducted two new experiments:

• Cross-domain transfer: A policy trained on translation, math, and code tasks was tested on unseen domains (QA, WSD, sentence completion), following the out-of-domain setup in PCB Merging. Results will be added to a new Out-of-Domain Generalization subsection.
• Zero-shot preference generalization: A well-trained policy network in HM3 was applied to two unseen vectors without further search, directly generating inference paths for model merging. The result is the following table.

These experiments evaluate generalization across both task domains and preference vectors. Results show that HM3’s policy generalizes effectively in a zero-shot setting, producing competitive merging paths. We will provide complete results and implementation details in the final revision to highlight the policy’s robustness and reusability.

Q3: We thank the reviewer for highlighting the importance of result stability. As HM3 performs joint search over parameter and architecture spaces, we address randomness by running the full pipeline 10 times per preference vector using different seeds. As shown in Figure 6, we report the mean and standard deviation across runs. The final reward is shown in W3 of Reviewer wkP4, which demonstrates the stability of HM3.

W1: We thank the reviewer for the valuable suggestions. Due to space constraints, we provided a concise overview of the models and tasks used in the evaluation. In the revised version, we have addressed the concern about insufficient experimental details with the following clarifications and additions:

Dataset splits and evaluation protocol: Each task adopts a 70/30 train/test split. The RL search strictly uses training data, and final performance is evaluated on the held-out test set to avoid data leakage. Task-specific metrics are now described in full, including their computation procedures.

Hyperparameter settings and stability: We have added a dedicated Hyperparameter List subsection in the appendix:

• Maximum number of iterations: 1000
• Policy and value networks begin updating after iteration $iter_0 = 200$
• PPO clipping ratio: 0.1
• Discount factor $\gamma$: 0.990
• GAE coefficient $\beta_A$: 0.95
• Loss coefficients: $c_1 = 1.0$ (value loss), $c_2 = 0.15$ (policy entropy)

We assess robustness via 10 runs with different seeds, reporting mean and standard deviation of rewards to illustrate training stability (see the result in W3 of Reviewer wkP4).

Runtime Environment: In the Experimental Platform section, we now report detailed hardware and software configurations. Qwen‑2.5‑1.5B was evaluated on four 3090 GPUs (24GB each), while LLaMA‑2‑7B and LLaMA‑2‑13B were evaluated on four A6000 GPUs (48GB each). All models can also be deployed on a single GPU. The software versions, dependency libraries, and parallelism settings are listed in the appendix.

To support reproducibility, we will release the source code upon paper acceptance.

W2/Q5: We thank the reviewer for the insightful comments on the scalability of HM3. This paper primarily focuses on architecture-level model merging and demonstrates the superiority of our approach over parameter-based baselines on several representative tasks and model scales. In response to the reviewer’s concerns, we provide a comprehensive discussion from three perspectives, i.e., tasks, models, and objectives, and supplement our claims with additional experiments.

Task-Level Scalability: Beyond Translation, Math, and Code, we incorporate GLUE benchmark as a new task domain, Generative/General Task . Additionally, we further expand task diversity in the current task domains:

• Translation: XNLI
• Math: MathQA
• Code: MBPP

The results are provided in W2 of Reviewer wkP4. HM3 maintains superior performance across all four domains, demonstrating robustness to both task number and variety.

Model-Level Scalability: HM3 relies on layer-wise features for trajectory selection, ensuring stable complexity regardless of model pool size. We also scale to LLaMA‑2‑13B and observe consistent gains, confirming effectiveness on larger models. The results of LLaMA‑2‑13B are provided in W2 of Reviewer wkP4 or W1 of Reviewer TWdc.

Objective-Level Scalability: In this work, we set the number of objectives to three—translation, math, and code—chosen due to their inherent conflicts and diversity, which are essential for forming a well-separated and sparse Pareto front in multi-objective optimization. Adding more objectives without sufficiently higher diversity (e.g., general language understanding) would shift the problem into the many-objective regime. This introduces challenges such as excessive front dimensionality, dense solution distributions, and dominance relation degradation, which are known to undermine the effectiveness of traditional multi-objective methods [1]. For these reasons, we do not include more objectives. But we will explicitly discuss the impact of objective count on problem complexity in the Discussion and Limitations sections, and outline future directions such as designing dedicated algorithms for many-objective model merging.

[1] B. Li, et al. Many-objective evolutionary algorithms: A survey. ACM Computing Surveys, vol. 48, no.1, pp. 1-35, 2015.

W3: We thank the reviewer for pointing out the spelling and notation issues. We have addressed them as follows:

Spelling: All typos (e.g., “optimity” → “optimality”) have been corrected through a full proofreading pass.

Notation consistency: We have standardized the notation throughout the paper as follows:

• Number of objectives: $K$
• Dimensionality of decision space: $d$
• Layer index: $l$
• Model index: $m$ All notations are now consistently used and clearly defined upon their first introduction in the main text.

Appendix: Section A.2.1 has been revised for consistent indexing, and a Notation Summary Table has been added for clarity.

We believe these revisions improve both clarity and formal consistency.

Q1: We sincerely thank the reviewer for their thoughtful comments on the concept of architecture-space merging. We would first like to clarify that the core innovation of our method lies in its ability to not only merge model parameters but also to extend or reorganize the architecture of the resulting model. This architectural flexibility offers the potential to overcome performance bottlenecks of a fixed architecture by enhancing the model’s representational capacity and task adaptability.

According to the scaling laws, such increases in more parameterized layers can improve model performance. For instance, SOLAR-10.7B [2] improved performance by concatenating the first 20 layers and the last 20 layers from Mixtral-7B, followed by continued pretraining. Our goal is to achieve similar architectural expansion via a training-free model merging.

In this work, we focus on architecture-level merging models via base models with similar architectures due to:

• Functional alignment, preserving semantic consistency after stitching.
• Reduced distributional shift, as models from the same base checkpoint are more compatible under MLP-based projection.
• Practicality, since merging fully-heterogeneous architectures (e.g., Qwen with LLaMA) leads to non-functional models due to severe misalignment (see the result in Q1 of Reviewer TWdc).

Thus, HM3 represents an intermediate step between traditional parameter merging and full architectural merging, similar to SOLAR-10.7B, but without additional training.

We will clarify these constraints and future directions in the Limitations and Future Work sections.

[2] D. Kim, et al. Solar 10.7 b: Scaling large language models with simple yet effective depth up-scaling. arXiv preprint arXiv:2312.15166, 2023.

Q2: We thank the reviewer for the suggestion. We agree that including an MOEA baseline is important for fair comparison. While results were briefly reported (Line 309), we now provide further clarification.

Experimental setup: Both HM3 and the MOEA baseline adopt the same decomposition-based multi-objective framework, sharing:

• Scalarization strategy
• Initialization seeds (10 per preference vector)
• 10 independent runs per method, with averaged results

Implementation: The MOEA baseline uses decomposed-based MOEA with differential evolution operator (pop. size = 30, crossover = 0.9, mutation = 0.1). Merging is performed via mergekit passthrough, aligned with evolutionary search method in W1 of Reviewer wkP4. Both methods use 4 GPUs under comparable evaluation budgets.

Results: Using a reference point (1.1, 1.1, 1.1), HM3 consistently achieves higher hypervolume than MOEA on LLAMA-2-7B across all runs, demonstrating superior search efficiency.

Q3: We thank the reviewer for the important question on preference specification. Our framework assumes users typically do not provide explicit preferences and supports two practical modes:

1. Offline preference sampling (Default): We uniformly sample preference vectors to approximate the Pareto front. Users can later select a model matching their needs—no input required.
2. Optional user preference injection: If a user specifies a preference (e.g., prioritizing translation), we select the closest model on the front or conduct a targeted search, enabling both automated and interactive use.

To ensure a fair comparison protocol, we sample the same preference vector across all methods when comparing HM3 with single-objective baselines, ensuring consistent optimization and evaluation conditions.

We will add a “Deployment Considerations” subsection in the appendix and clarify in the main text that all baselines are evaluated under the same preference settings.

Q4: We thank the reviewer for the insightful comment on HV calculation. We acknowledge the initial reference point was suboptimal and have corrected it during the review phase.

We now use (1.1, 1.1) for bi-objective cases, and (1.1, 1.1, 1.1) for tri-objective cases.

This follows standard practice in toolkits like PlatEMO [3], where the reference point is set slightly beyond the estimated nadir to ensure valid HV computation and full Pareto coverage.

Experimental results have been updated accordingly, and Line 606 in the manuscript now states:

“The reference point is set slightly beyond the nadir (e.g., (1.1, 1.1, 1.1)) to ensure non-zero HV and full coverage of the Pareto front.”

We believe this addresses the concern and improves clarity in our evaluation.

[3] Y. Tian, et al. PlatEMO: A MATLAB platform for evolutionary multi-objective optimization. IEEE Computational Intelligence Magazine, vol. 12, no. 4, pp. 73-87, 2017.

W1/Q1: We thank the reviewer for the suggestion regarding the reinforcement learning details. In the revised manuscript, we have provided the clarifications from the method and experiment aspects:

Method Aspect: We first clarify the components of RL. In this work, the architecture-level model merging problem is formulated as an MDP:

1)State Space: We define the state as the trajectory of selected models and layers. Then, the model index, layer index, and layer parameters are embedded by learnable encoders, and map the trajectory into a state vector via a GRU.

2）Action Space: The action is defined as selecting the next discrete pair of model index and layer index from the candidate model pool. As a discrete action space, we design a Wolpertinger discretization strategy to enhance the efficiency of discrete sampling and assist in selecting the next action.

3）Reward Function: To encourage efficient inference paths while ensuring performance, the total reward of a trajectory is defined as a weighted performance minus a penalty for the path length.

Q1: The reward function is computed after the entire inference path (trajectory) is generated and the MLP-based alignment is performed. The resulting model is evaluated, and the obtained reward is uniformly assigned to all time steps in the trajectory as $R_t$, which is used to train both the policy and value networks. In the original version, the description of the reward function may cause a misunderstanding.

Therefore, in the revised manuscript, we updated the reward formula as:
R = \sum_{k=1}^K \lambda_k^{(i)} f_k(\boldsymbol{\theta},~\pmb{h}) - \beta_1 T\ to indicate that reward obtained by model evaluation after obtaining the complete inference path and performing MLP alignment, thus ensuring the rigor and correctness of reward calculation.

Based on the above MDP, the execution of the RL is the following stages:

Stage 1: Input and initialization: The algorithm begins by sampling $N$ preference vectors, each corresponding to a decomposed subproblem in the multi-objective framework. For each preference vector, an existing parameter-level merging method is applied to obtain an initial merged model parameter. Meanwhile, the parameters of the policy, value, and the MLP network for alignment are initialized.

Stage 2: Trajectory collection and MLP alignment: For each preference vector, an inner loop is executed in RL. In each iteration, the parameter-level merged model and the fine-tuned models are evaluated to compute the reward and stored in the trajectory buffer. Then, at each step, the current trajectory-encoded state is used to generate a proto-action, which is discretized via the Wolpertinger policy to select the next action. The new state is converted, and the transition is recorded in the buffer. Once a complete path is collected, the algorithm performs MLP alignment.

Stage 3: Reward computation and network update： After the alignment, the reward is computed and then is assigned to all time steps in the trajectory. Once the iteration number exceeds $iter_0$, the algorithm enters the network update phase. In this phase, a mini-batch is sampled from the buffer to compute GAE and target returns. The policy, value network, and MLP alignment network are updated. The entire process continues until Max_iter is reached, yielding the final policy network and the optimal inference paths. The well-trained networks can be reused for new tasks or model pools.

**Experiment Aspect: **The hyperparameters of RL are: Max_iter is 1000; the networks begin updating after $iter_0 = 200$; the PPO clipping ratio is 0.1; $\gamma$ is 0.990; the GAE smoothing factor $\beta_A$ is 0.95. The loss coefficients are $c_1 = 1.0$ and $c_2 = 0.15$. We split the dataset where 70% is used for RL inference evaluation, while the 30% is reserved for the evaluation of the obtained merged model. Finally, in the revised version, we conduct 10 independent runs with different random seeds and report the mean and variance to assess the stability of the RL policy training. The detailed result of RL convergence is provided in W3 of Reviewer wkP4.

W2: We sincerely thank the reviewer for the valuable feedback and fully understand the underlying concern. While it is true that parameter merging generally requires the same parameter initialization, this condition does not apply to the outer-loop optimization in HM3.

To elaborate, in HM3, the outer-loop optimization selects a source model for each layer based on $(m_t, l_t)$, and parameter merging is only performed among models in the pool that share the same architecture as the selected source model. If the selected layer originates from a model that has no architectural counterparts in the pool, parameter merging is simply skipped. Therefore, the outer-loop optimization itself does not rely on a unified parameter initialization across models.

Our approach indeed involves optimization over both model parameters and model architecture, reflecting a two-level decision process. To clarify this point, we have revised the manuscript to provide a more direct explanation of HM3 as follows:

The lower-level optimization searches for the optimal merged model architecture. The resulting architecture determines the length of the inference path (i.e., the number of layers to be merged). The upper-level optimization then operates on the parameter set $\\{\theta_{m_t,l_t}\\}_{t=1}^T$ corresponding to this architecture.

Consequently, the optimal architecture found by the lower level dynamically determines the dimensionality and scale of the parameter search space for the upper level. This naturally forms a hierarchical decision-making structure—first optimizing the model architecture, then optimizing the corresponding model parameters—which embodies the core hierarchical nature of our HM3 method.

We hope this clarification resolves the misunderstanding and highlights the distinct roles of architecture and parameter optimization.

W3: We greatly appreciate the reviewer’s insightful concern. We understand that the interaction between the upper- and lower-level appears to resemble an alternating optimization. However, we would like to emphasize that HM3 is fundamentally a bilevel optimization rather than an alternating optimization procedure. This distinction is evident in the following aspects:

(i) Different objective functions across levels: The upper-level optimization maximizes the performance $\mathcal{F}$ of the merged model, while the lower-level optimization is formulated as an MDP with a reward function that combines model performance and inference path length: $R = \mathcal{F} - \beta_1 T$. The two levels optimize different functions characterized as bilevel optimization, while alternating optimization decomposes a single objective into interleaved subproblems.

(ii) Strict dependency between levels: the upper-level optimization in HM3 can only be performed after the lower-level has searched an optimal architecture. This requirement of solving the lower-level problem to optimality before proceeding to the upper-level is a key feature of bilevel optimization.

(iii) Variable interaction: Interaction variables such as the inference path length $T$ are determined exclusively by the lower-level architecture search and are then passed to the upper-level optimizer.

To avoid confusion, we have revised the manuscript to update $\mathcal{P}2$, making clear the essential distinction between the objectives of the two levels and their interaction structure.

Q2: We begin with sampling preference vectors. For each preference vector, the layer selection process is modeled as an MDP, as detailed in W1/Q1. Specifically, the trajectory of selected layers is embedded into a state vector via a learnable encoder. Based on this state, the policy network outputs a continuous proto-action vector, which is mapped to a discrete action using the Wolpertinger policy: it first identifies the nearest neighbors based on the distance to the proto-action vector, constructs a candidate set, and then selects the action that maximizes the value network or performs random exploration. The final action determines the next layer to be appended to the inference path.

This process yields an inference sequence. For every adjacent layer in this sequence, we apply an MLP-based alignment to address potential mismatches in dimension and representation. Specifically, we first detect their input/output dimensions. Then, for each layer, we compute statistical descriptors of its representation, i.e., mean, variance, and distribution characteristics. The proposed MLP network generates a projection matrix that transforms the representation of the preceding layer to align it with the following one in terms of both dimensionality and distribution. The transformed features are then seamlessly passed to the subsequent layer, enabling compatible inter-layer connections across different models. Preliminary experiments indicate that incorporating MLP-based alignment leads to improvements in final performance.

MLP-based alignment is applied between adjacent layers in the inference path. As in W5 of Reviewer wkP4, learning-based layer stitching via MLP projection remains underexplored. Therefore, in the revised version, we state that the proposed MLP-based projection is in its early exploratory stage. In the Discussion section, we outline possible future directions.

Dear Reviewer B6zw,

We would like to kindly ask whether our responses have addressed your concerns. If there are any remaining questions or points that require further clarification, we would be more than happy to discuss them.

Thank you once again for your valuable time and insightful feedback! We truly appreciate your thoughtful review and constructive suggestions, which have greatly helped us improve our work.