Evolutionary Generative Merging (EvoGM)

• EvoGM is a framework that optimizes merging coefficients in a shared task-vector space derived from fine-tuned models, enabling gradient-free fusion without full retraining.
• It employs a dual-generator architecture with cycle consistency to learn evolution operators from winner–loser pairs, replacing traditional stochastic search methods.
• The method features multi-round evolution with basis shifts, progressively refining expert models and delivering significant improvements on both seen and unseen tasks.

Searching arXiv for EvoGM and related evolutionary model merging papers. Evolutionary Generative Merging (EvoGM) is a framework for learning to merge LLMs via evolutionary generative optimization. It formulates model merging as a parameter-space search over coefficient vectors applied to task vectors derived from models fine-tuned from a shared pretrained base, and replaces hand-crafted stochastic search operators with a learnable generative mechanism. In EvoGM, a dual-generator architecture with cycle-consistent learning is trained on winner–loser pairs extracted from historical search trajectories, and the resulting generator is embedded in a multi-round evolutionary pipeline in which elite merged models become new expert foundations for later rounds (Jiang et al., 28 May 2026).

1. Definition and problem setting

EvoGM addresses the problem of selecting merging coefficients for a collection of task-specific models without gradients and without full retraining. The target setting assumes several task-specific models fine-tuned from the same pretrained model, so that merging can be expressed in terms of task vectors rather than unrestricted weight recombination. The stated motivation is that the coefficient space is smaller than full parameter space but remains highly nonconvex and expensive to evaluate, especially under small validation budgets, while grid search is infeasible and static heuristics such as task arithmetic, model soups, TIES, and DARE are largely hand-designed (Jiang et al., 28 May 2026).

The framework is explicitly positioned against earlier evolutionary model-merging procedures that rely on stochastic perturbations, crossover, or swarm-style updates but do not learn the structure of high-performing regions in coefficient space. EvoGM therefore treats the search procedure itself as a learnable object. Its central claim is not merely that evolutionary search is useful, but that winner–loser search history can be turned into a generative model of promising coefficient distributions (Jiang et al., 28 May 2026).

A useful distinction within the literature is that EvoGM is a specific framework, whereas evolutionary generative merging can also denote a broader research direction. Earlier work on re-purposing heterogeneous GAN generators used evolutionary algorithms to optimize ensemble membership and mixture weights for a new objective, improving Total Variation Distance while preserving Frechet Inception Distance on MNIST (Toutouh et al., 2020). This suggests that the broader paradigm predates EvoGM, but EvoGM specializes it to coefficient-space optimization for LLM merging.

2. Optimization formulation in coefficient space

EvoGM models the merged checkpoint as

$$\boldsymbol{\theta}(\boldsymbol{\lambda}) = \boldsymbol{\theta}_{pre} + \sum_{i=1}^N \lambda_i \boldsymbol{\tau}_i, \quad \text{where } \boldsymbol{\tau}_i = \boldsymbol{\theta}_i - \boldsymbol{\theta}_{pre},$$

and seeks

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$

Here, the search variables are the coefficients $\boldsymbol{\lambda}$, not the full model parameters. This makes the optimization compatible with training-free merging, while preserving a direct connection to standard task-vector formulations (Jiang et al., 28 May 2026).

The evolutionary process begins with a population

$$\mathcal{P} = \{\boldsymbol{\lambda}^{(p)}\}_{p=1}^P,$$

where the default population size is $P = 2N$. Initialization is hybrid: average merging with $\lambda_i = 1/N$, one-hot vectors corresponding to individual experts, and uniformly sampled random vectors are all included. Each candidate is evaluated on validation data and stored in a history archive,

$$\mathcal{H}=\{(\boldsymbol{\lambda}, f(\boldsymbol{\lambda}))\}.$$

This archive is not a passive record; it is the supervision source for the generative component of the method (Jiang et al., 28 May 2026).

The historical archive is partitioned into a winner set $\mathcal{H}^+$ containing the top-$\rho$ fraction by validation score and a loser set $\mathcal{H}^-$ containing the remainder, with default winner ratio $$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$0. Training pairs are formed from the Cartesian product

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$1

This pairing strategy means that EvoGM learns relative improvement directions rather than simply fitting a density over elite points (Jiang et al., 28 May 2026).

3. Dual-generator architecture and learned evolutionary operators

The distinctive mechanism in EvoGM is a dual-generator system. One generator, $$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$2, maps loser coefficients to winner-like coefficients, while the other, $$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$3, maps winner coefficients back to loser-like coefficients. Both are implemented as five-layer MLPs, and the output layer uses $$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$4 so that generated coefficients remain in $$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$5 (Jiang et al., 28 May 2026).

Training uses a weighted sum of cycle consistency and optimization guidance,

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$6

The cycle-consistency term is

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$7

The winner-set centroid is

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$8

and the optimization-guided term is

$$\boldsymbol{\lambda}^* = \arg\max_{\boldsymbol{\lambda}} f(\boldsymbol{\theta}(\boldsymbol{\lambda}); \mathcal{D}_{val}).$$9

The first term regularizes the mappings to be reversible and avoids trivial collapse; the second explicitly moves loser samples toward the empirical center of elite solutions (Jiang et al., 28 May 2026).

Once trained, $\boldsymbol{\lambda}$0 functions as a learned mutation operator:

$\boldsymbol{\lambda}$1

Generated candidates are evaluated, added to the historical archive, and the population is updated by retaining the top-$\boldsymbol{\lambda}$2 candidates. The evolutionary loop is therefore not based on hand-crafted perturbation alone. It repeatedly re-estimates a proposal distribution over promising coefficient regions from search history, which is the main technical sense in which the method is generative (Jiang et al., 28 May 2026).

An important misconception is that EvoGM is merely another random-search or swarm-based merger. Its defining property is precisely the replacement of manual stochastic operators by a learned mapping from weak to strong coefficient regions. The ablation results support the importance of this design: removing the dual-generator structure degrades performance, and removing cycle consistency produces a clear drop, especially on reasoning tasks (Jiang et al., 28 May 2026).

4. Multi-round evolution and basis shift

EvoGM includes an outer loop in which the expert basis itself changes over time. At the end of each round $\boldsymbol{\lambda}$3, the method selects the top-$\boldsymbol{\lambda}$4 coefficient vectors from the accumulated history,

$\boldsymbol{\lambda}$5

and synthesizes a new expert pool:

$\boldsymbol{\lambda}$6

Task vectors are then recomputed relative to the original pretrained model,

$\boldsymbol{\lambda}$7

This procedure is described as a basis shift: later rounds search in a newly induced expert space built from elite merged models rather than the original fine-tuned experts (Jiang et al., 28 May 2026).

The intended effect of basis shift is to escape local optima and refine the search trajectory. Convergence plots reportedly show that EvoGM improves more steadily than PSO-Merging and Model Swarm, which typically plateau around iteration 5, while EvoGM exhibits an additional performance jump after the round transition. The temporary dip at the start of a new round is explicitly described as expected because of basis resetting (Jiang et al., 28 May 2026).

In the main experiments, a typical configuration is 2 rounds and 3 iterations per round. Parameter-sensitivity analysis further indicates that larger populations generally help, more rounds help, 200–400 generator epochs are sufficient, a smaller learning rate such as $\boldsymbol{\lambda}$8 works best in the reported tuning, and increasing evolution rounds from 1 to 5 improves performance (Jiang et al., 28 May 2026).

This multi-round design differentiates EvoGM from methods that search a fixed merge space once and return a single optimum. It also differentiates it from approaches in which the outer loop is simply reinitialization. A fairness check reported for EvoGM states that giving PSO-Merging the same multi-round basis-reset schedule does not help and in fact hurts, which is used to argue that the gains arise from the specific combination of basis shift, winner–loser generative modeling, and cycle consistency rather than from resetting alone (Jiang et al., 28 May 2026).

5. Empirical evaluation and reported results

EvoGM is evaluated in both seen-task and unseen-task settings. The first model family uses FLAN-T5-base with 8 experts fine-tuned on GLUE tasks. The second uses Qwen2.5-1.5B with 10 LoRA-based experts fine-tuned on Tulu-v2 SFT domains. The experts are trained for 5 epochs with learning rate $\boldsymbol{\lambda}$9 and effective batch size 32 (Jiang et al., 28 May 2026).

The seen-task benchmark consists of eight GLUE tasks: CoLA, MNLI, MRPC, QNLI, QQP, RTE, SST-2, and STS-B. On this 8-task GLUE benchmark, EvoGM achieves the best average performance, with EvoGM average 82.4 compared with the best prior baseline, PSO-Merging, at 81.2. Individual task values highlighted in the paper include CoLA 71.1, QQP 84.8, RTE 82.2, and STS-B 80.9, each marked as best overall (Jiang et al., 28 May 2026).

The unseen-task evaluation covers eight tasks across knowledge, reasoning, and safety: MMLU, MMLU-Pro, HellaSwag, GSM8K, Knowledge Crosswords (K-Cross), NLGraph, TruthfulQA, and AbstainQA. In the single-task merging setting on Qwen2.5-1.5B with 10 experts, EvoGM attains the highest test accuracy on 5 of 8 benchmarks. The table values highlighted include MMLU 0.625, HellaSwag 0.594, GSM8K 0.434, NLGraph 0.537, and TruthQA 0.441. The paper specifically reports a 15% relative gain on NLGraph over PSO-Merging (Jiang et al., 28 May 2026).

In the multi-task setting, where one merged model is evaluated across all 8 unseen tasks, EvoGM again achieves the best average. The reported average is 0.380, compared with MTL 0.330, Base 0.352, PSO-Merging 0.372, Model Swarm 0.372, and CMA 0.375. The paper also reports a 66% relative improvement on AbstainQA over the strongest evolutionary baseline (Jiang et al., 28 May 2026).

Additional scaling and robustness experiments extend beyond the primary Qwen2.5-1.5B setting. For Qwen3-8B with 10 experts, EvoGM achieves the best average score, 0.603, exceeding Model Swarm at 0.593. In a 20-expert ViT-B-16 merging experiment, EvoGM obtains 0.6363 versus 0.6268 for CMA-ES. Multi-seed robustness analysis reports that EvoGM’s average on unseen tasks is statistically better than PSO-Merging with $$\mathcal{P} = \{\boldsymbol{\lambda}^{(p)}\}_{p=1}^P,$$0 and Model Swarm with $$\mathcal{P} = \{\boldsymbol{\lambda}^{(p)}\}_{p=1}^P,$$1 (Jiang et al., 28 May 2026).

6. Relation to adjacent frameworks, distinctions, and limitations

EvoGM belongs to a rapidly expanding line of research on training-free or low-training-cost evolutionary merging. MERGE$$\mathcal{P} = \{\boldsymbol{\lambda}^{(p)}\}_{p=1}^P,$$2 focuses on the fitness-evaluation bottleneck by combining reduced evaluation subsets, Item Response Theory ability estimation, and IRT-based performance estimators, achieving a reported 50-fold reduction in compute and enabling state-of-the-art multilingual and cross-lingual merging on a single consumer GPU (Mencattini et al., 9 Feb 2025). Mergenetic is described as an open-source library that enables easy composition of merging methods and evolutionary algorithms while incorporating lightweight fitness estimators to reduce evaluation costs, and its abstract claims competitive results across tasks and languages using modest hardware (Minut et al., 16 May 2025). This suggests that EvoGM can be understood not as an isolated algorithm but as one branch within a broader shift toward automated post hoc model composition.

Other contemporary systems illuminate what EvoGM is and is not. Evo-L2S formulates Long-to-Short reasoning as a multi-objective optimization problem and uses NSGA-II to recover a Pareto front trading off accuracy and output length, with an entropy-based subset sampling procedure for tractable fitness estimation (Iacobelli et al., 7 Apr 2026). Darwin Family performs training-free evolutionary merging via gradient-free weight-space recombination, introduces a 14-dimensional adaptive merge genome, MRI-Trust Fusion, and an Architecture Mapper for cross-architecture breeding, and reports 86.9% on GPQA Diamond for Darwin-27B-Opus (Kim et al., 14 May 2026). EvoMerge, by contrast, treats merging as crossover and fine-tuning as mutation in a broader neuroevolution loop, but remains an exploratory prototype with limited formal specification (Jiang, 2024). Relative to these systems, EvoGM is specifically a homogeneous, coefficient-space method with learned generative search operators and multi-round basis refinement.

Two limitations are explicitly stated for EvoGM. First, it assumes homogeneous merging only: all experts must come from the same pretrained base model, so the coefficient space is well defined. It is not directly applicable to heterogeneous architectures or differently initialized models without alignment. Second, it is single-objective: the current multi-task setup optimizes a single scalar validation objective and returns one merged model rather than a Pareto set for multiple user preferences (Jiang et al., 28 May 2026).

A further common misconception is that evolutionary merging necessarily implies arbitrary full-weight recombination. EvoGM does not operate in that regime. Its search space is the coefficient vector over task vectors derived from a shared base, and its novelty lies in learning how to traverse that coefficient space from historical winner–loser structure. Conversely, Darwin’s cross-architecture breeding and Architecture Mapper, or Evo-L2S’s explicit Pareto optimization, are not properties of EvoGM itself (Jiang et al., 28 May 2026).

Taken together, the literature indicates a progressive refinement of evolutionary merging from heuristic ensemble search, through efficient consumer-GPU frameworks and diagnostic-guided recombination, toward learned generative optimization over merge coefficients. Within that progression, EvoGM is distinguished by its dual-generator, cycle-consistent modeling of coefficient-space transitions and by its multi-round mechanism in which elite merges recursively redefine the expert basis (Jiang et al., 28 May 2026).