Cryptographic Provenance in Evolutionary Model Breeding: A Deterministic Manifest Framework for Rust-Based Verification

Full report

On this page

Introduction to the Evolutionary Paradigm of Model Composition

The rapid proliferation of Small Language Models (SLMs) has catalyzed a paradigm shift in artificial intelligence development. Instead of relying exclusively on computationally intensive gradient-based training from scratch, the machine learning community is increasingly adopting "model breeding." This evolutionary methodology involves the training-free, post-hoc composition of disparate models into highly capable, unified architectures1. By leveraging evolutionary optimization of model merging recipes, practitioners can synthesize cross-domain capabilities—such as injecting advanced mathematical reasoning into a culturally aware linguistics model—without experiencing catastrophic forgetting or necessitating access to raw training data2. The operational efficiencies achieved through these methods drastically reduce the carbon footprint and computational costs associated with foundation model development1. However, as model breeding scales into decentralized pipelines, automated evolutionary searches, and agentic environments, a critical vulnerability emerges: the absolute lack of verifiable digital provenance. The model supply chain is currently plagued by structural opacity. Over 1,400 malicious models have been identified and removed from public repositories, highlighting the reality that training data poisoning and backdoor triggers embedded in weights are persistent threats8. When a model's lineage is obscured, users cannot cryptographically prove its safety alignment, its parent compatibility, or the absence of malicious parameter tampering8. Traditional software supply chains rely on source code auditing and deterministic compilation, but neural networks distribute their logic across billions of floating-point parameters, rendering verification through source analysis mathematically impossible8. To secure the artificial intelligence supply chain, the ecosystem requires deterministic verification frameworks capable of operating in resource-constrained environments, particularly browser-local systems powered by WebAssembly (WASM) and Rust. Rust’s strict memory safety, zero-cost abstractions, and deterministic execution characteristics make it the optimal systems-level language for parsing byte-stable weight formats and enforcing strict cryptographic lineage10. This comprehensive report provides an exhaustive analysis of eleven foundational model breeding techniques. For each method, the analysis delineates the exact mathematical mechanisms, origin, and future outlook, followed by an explicitly defined metadata schema. These schemas dictate what must be embedded in cryptographic receipts (manifests) to allow a browser-local Rust system to definitively prove lineage, parent compatibility, fitness, schedule, checksum, and reproducibility.

Architectural Foundations for Rust-Based Verification

To perform local verification without relying on trusted central authorities, a Rust-based system must consume a deterministic manifest alongside the model weights. Traditional weight serialization formats, such as the PyTorch .pt format, are fundamentally unsuited for this application due to embedded timestamps, arbitrary code execution risks via the Python pickle module, and non-deterministic serialization structures12. Instead, the verification system must rely on the Safetensors format, which enforces an 8-byte aligned, byte-stable layout ideal for zero-copy memory mapping (mmap) and deterministic hashing13.

The C2PA Cryptographic Substrate

The verification engine must parse a manifest compliant with the Coalition for Content Provenance and Authenticity (C2PA) standard15. The C2PA manifest acts as a tamper-evident digital receipt, containing assertions cryptographically bound to the model weights. While C2PA is frequently utilized for media provenance, its Concise Binary Object Representation (CBOR) architecture is uniquely suited for tracking the lineage of neural network tensors15. A standard C2PA manifest relies on c2pa.actions to log transformations (e.g., pruning, merging) and c2pa.hash to provide hard cryptographic bindings to the underlying data15. However, standard hashing verification encounters a critical paradox when applied to floating-point mathematics across heterogeneous hardware.

The Floating-Point Determinism Paradox

Because floating-point operations—particularly Fused Multiply-Add (FMA) instructions—exhibit non-associativity across different hardware architectures (e.g., x86 versus ARM), a browser-local Rust verifier executing complex matrix algebra will inevitably produce sub-ulp (unit in the last place) deviations19. The dynamic batching kernel reductions utilized by modern GPUs further exacerbate this non-determinism21. Consequently, twenty-six standard neural network merge strategies fail the algebraic properties (commutativity, associativity, idempotency) required for conflict-free distributed operation2. If the verification protocol relies exclusively on cryptographic hashing (BLAKE3/SHA-256) of the resulting tensor files, hardware-induced floating-point noise will cause the checksums to fail on local machines, throwing false-positive corruption alerts12. To resolve this, the Rust system must implement a bifurcated verification strategy utilizing a Nondeterministic-tolerance Aware Optimistic (NAO) verification protocol. Rather than demanding bitwise equality, the NAO protocol computes the expected theoretical parameters using software-defined strict IEEE-754 fallback functions and asserts that the published tensor weights fall within a principled, operator-level acceptance region defined by an [Figure omitted from source export] boundary12. Alternatively, for exact bit-for-bit verification, models must be quantized into deterministic integer spaces, such as 2-bit ternary formats where weights are strictly [Figure omitted from source export]25. In this domain, matrix multiplications are reduced to pure hardware addition and subtraction, entirely sidestepping floating-point noise and enabling exact cryptographic hashing across all platforms25.

Taxonomy of Model Breeding Techniques and Metadata Receipts

The following sections exhaustively deconstruct eleven primary model breeding methodologies. Each section defines the core mechanism and provides a structured metadata matrix detailing the specific cryptographic requirements for a Rust-based verification client to prove the six core pillars of provenance: Lineage, Parent Compatibility, Fitness, Schedule, Checksum, and Reproducibility.

1. Parameter Averaging (Linear & SLERP)

Parameter averaging is the most fundamental merging technique, operating on the premise that models fine-tuned from the same base initialize within the same local minimum basin. Linear interpolation computes a simple weighted average of the weights26. However, in the high-dimensional spaces characteristic of modern SLMs, linear interpolation often decreases the magnitude of the interpolated vectors, causing catastrophic degradation of the weight scale27. Spherical Linear Interpolation (SLERP) circumvents this limitation by interpolating along the geometric arc between two weight vectors rather than drawing a straight chord, maintaining the unique curvature and scale of the model weight surfaces27. The SLERP operation normalizes the vectors to unit length to extract their direction, computes the angle [Figure omitted from source export] between them via the dot product, and applies the geometric translation: [Figure omitted from source export] If the vectors are nearly collinear, SLERP falls back to linear interpolation to avoid division-by-zero instability27. Looking forward, as models scale, geometric interpolation methodologies are expanding to incorporate Karcher Mean calculations and optimal transport theories, allowing for the interpolation of multiple models simultaneously rather than relying strictly on pairwise SLERP operations30.

2. Task-Delta Merging (Task Arithmetic)

Task Arithmetic treats neural network fine-tuning as a directional vector within the parameter space. Instead of merging raw weights, this methodology isolates the specific "learned capability" by subtracting the pre-trained base model weights ([Figure omitted from source export]) from the fine-tuned model weights ([Figure omitted from source export]) to generate a task vector ([Figure omitted from source export])26: [Figure omitted from source export] These task vectors can be algebraically manipulated—added together to enhance multiple capabilities simultaneously, or negated (subtracted) to induce targeted forgetting of specific behaviors, such as mitigating toxic outputs or removing memorized copyright data26. The final model is constructed by adding the scaled task vectors back to the base model: [Figure omitted from source export] This mechanism underpins the modular, decentralized development of SLMs, enabling organizations to rapidly update or customize models without incurring the massive computational costs of multi-task joint retraining30.

3. Sparse Task-Delta (MAGPRUNE / DELLA)

Merging dense task vectors often introduces parameter interference, where overlapping weight updates overwrite one another, leading to a severe degradation in multi-task capability. Sparse task-delta methods, such as Drop and rEscaLe via sampLing with mAgnitude (DELLA), address this interference by introducing a magnitude-based pruning technique (MAGPRUNE)37. This technique operates under the assumption that parameters exhibiting the largest absolute magnitudes represent the most critical, task-specific knowledge. DELLA ranks the task vector parameters by magnitude and assigns a dropout probability [Figure omitted from source export] inversely proportional to the rank. Parameters with lower magnitudes receive higher dropout probabilities. The surviving parameters are then mathematically multiplied by a rescaling factor [Figure omitted from source export] to maintain the original mathematical expectation of the embedding magnitudes, a principle borrowed from traditional neural network dropout layers37. This approach has demonstrated average improvements of 2.4 points over baseline methods employing delta parameter pruning on benchmarks such as AlpacaEval and GSM8K37.

4. Drop And Rescale (DARE)

While DELLA relies on magnitude, the Drop And REscale (DARE) method operates on uniform probability. DARE acts as an extreme sparsification technique, successfully dropping up to 99% of delta parameters in homologous models while retaining core capabilities26. By identifying and eliminating redundant delta parameters (setting them to zero), DARE drastically reduces parameter interference, particularly when merging multiple Supervised Fine-Tuning (SFT) models derived from the same backbone27. Given a task vector [Figure omitted from source export], DARE applies a Bernoulli mask [Figure omitted from source export]. The sparsified and rescaled vector is represented mathematically as: [Figure omitted from source export] The rescale operation is critical; it compensates for the dropped parameters by proportionally increasing the impact of the remaining weights, thereby keeping the model's output expectations approximately unchanged27. DARE is rarely used in isolation; it acts as a force multiplier when combined with other methods (such as DARE-TIES), effectively projecting the task vector into a highly sparse, non-interfering subspace prior to fusion26.

5. Sign-Aware Merge (TIES)

TIES-Merging (Trim, Elect Sign, and Merge) explicitly addresses "sign-disagreement interference," a phenomenon that occurs when different fine-tuned experts update a parameter in opposing directions (e.g., Expert A dictates [Figure omitted from source export], while Expert B dictates [Figure omitted from source export])27. Under naive averaging, these conflicting updates result in destructive cancellation, degrading the final model's performance27. TIES resolves this conflict through a highly structured three-step algorithmic pipeline:

1. Trim: Prunes the bottom [Figure omitted from source export] of parameters in each task vector based on absolute magnitude, effectively zeroing out small-magnitude noise and addressing redundant-parameter interference34.
2. Elect Sign: For each parameter index, a dominant direction (sign) is elected. This is executed by summing the trimmed task vectors across all experts and extracting the sign of the resulting sum: [Figure omitted from source export]34.
3. Disjoint Merge: The final parameter is calculated as the average of only the trimmed expert values that share the elected sign [Figure omitted from source export]. Parameters that opposed the dominant direction are entirely excluded from the average, and coordinates where no expert agrees with the elected sign revert to the base value27.

6. Model Soup (Greedy, Uniform, and Instant Soup Pruning)

The Model Soup methodology leverages multiple checkpoints generated during a single fine-tuning run, or models fine-tuned with different hyperparameter seeds, and averages their weights to achieve a broader, flatter local minimum28. This technique enhances generalization and reduces overfitting without increasing inference time, and has proven highly effective not just for SLMs, but also for Graph Neural Networks (GNNs) handling ginormous graph-structured relational data43. While Uniform Soup simply averages all available checkpoints, Greedy Soup operates sequentially. It evaluates the checkpoints against a validation dataset, selects the best-performing model, and then iteratively adds the next-best model to the "soup." If the inclusion of the new model improves validation accuracy, the weights are permanently merged; if performance degrades, the model is discarded from the composition28. Furthermore, advancements like Instant Soup Pruning (ISP) adapt this concept to the sparse setting, generating miniature weak/noisy subnetworks and superposing them to average out noise, significantly reducing the computational cost of Iterative Magnitude Pruning (IMP)46.

7. Crossover (Data Flow Space & Parameter Space)

Borrowing extensively from genetic algorithms and neuroevolution, Crossover techniques splice components from different models to breed entirely new architectures. This operates across two distinct vectors4:

1. Parameter Space (PS): Recombining parameters between homologous layers, often leveraging TIES or DARE as the crossover operator to blend the weights mathematically.
2. Data Flow Space (DFS): Colloquially known as "frankenmerging," this involves structural crossover. DFS merges bypass weight arithmetic entirely; instead, they directly stack, drop, or shuffle verbatim transformer layers from different models (e.g., chaining layers 1-16 of Model A with layers 9-32 of Model B to create an asymmetric, cross-domain mixture)4.

DFS crossover exploits the fact that the middle layers of transformer architectures often share a common representation space and can operate somewhat interchangeably, despite not being explicitly trained to do so53. The evolutionary optimization of both PS and DFS allows for the creation of culturally-aware models and cross-domain experts without gradient descent4.

8. Mutation (Targeted Noise & Incremental Fine-Tuning)

In an evolutionary breeding algorithm, once models cross over, they must undergo mutation to escape local minima and introduce novel capabilities. In model breeding, mutation is simulated via brief periods of targeted fine-tuning (e.g., repetitive Direct Preference Optimization \- DPO), low-rank gradient injection, or controlled stochastic noise injection into the parameter space51. This forces slight structural divergences, generating a diverse population of candidates for the next epoch of merging, mimicking the biological process of spontaneous genetic alteration51.

9. Unstructured Pruning (Wanda & Magnitude)

Pruning induces sparsity in an SLM to massively reduce computational overhead and memory requirements. Magnitude pruning simply zeroes out parameters with the lowest absolute values57. However, Wanda (Pruning by Weights and activations) has emerged as a highly effective, training-free alternative that significantly outperforms simple magnitude pruning in zero-shot tasks57. Wanda calculates a metric [Figure omitted from source export] for each weight by multiplying its magnitude by the [Figure omitted from source export] norm of its corresponding input activation: [Figure omitted from source export] Wanda requires a forward pass of a small calibration dataset to establish the activation norms [Figure omitted from source export]. Once computed, the weights with the lowest scores are dropped57. This technique is frequently implemented in a structured [Figure omitted from source export] sparsity pattern (exactly two zeros per four consecutive weights) to explicitly leverage NVIDIA hardware acceleration via Sparse Tensor Cores, delivering a theoretical 2x speedup on dense matrix multiplications58. Furthermore, statistical bounds like the Effective Number of Parameters (EMP) provide adaptive thresholds to optimize the exact sparsity ratio without manual tuning62.

10. Adapter Fusion (Dynamic LoRA Merging)

Low-Rank Adaptation (LoRA) allows for parameter-efficient fine-tuning by introducing trainable low-rank matrices [Figure omitted from source export] and [Figure omitted from source export], such that the weight update is [Figure omitted from source export]63. Adapter Fusion merges multiple LoRA modules dynamically to handle complex, multi-domain composite queries. Methods like qa-FLoRA, Top-K Adaptive Fusion (K-LoRA), and Null-space Projection (NP-LoRA) calculate fusion weights dynamically without re-training, often by measuring the distributional divergence between the base model and the adapters64. The fused adapter is generally represented as: [Figure omitted from source export] where the coefficients [Figure omitted from source export] can be determined through static scaling, centroid similarity, or query-adaptive gated mixtures64. When merging LoRAs of heterogeneous ranks, complex SVD (Singular Value Decomposition) rank harmonization is required to align the linear algebra spaces24.

11. Population-Based Selection (Evo-Merging & IRT)

Evolutionary model merging automates the discovery of optimal merge coefficients, transcending manual heuristics55. Frameworks like Sakana AI's Evolutionary Model Merge and EvoGM initialize a massive population of merging configurations (coefficients [Figure omitted from source export]), evaluate them on a validation set, and utilize algorithms like CMA-ES (Covariance Matrix Adaptation Evolution Strategy) to dynamically sample and refine promising merging candidates over generations4. Because evaluating thousands of SLM candidates per generation is computationally disastrous, optimized frameworks utilize Item Response Theory (IRT) to estimate model fitness accurately by testing on a mathematically minimized, intelligent sample of data tokens, reducing fitness computation costs by up to 50x68.

Lineage Proofs and CRDT Integration in Decentralized Merging

When model breeding moves from isolated laboratories to decentralized, open-source networks, synchronization conflicts emerge. If Node A and Node B concurrently generate high-fitness mutations of an SLM and attempt to merge them into a shared repository, standard linear version control systems fail, leading to catastrophic parameter overwrites8. To facilitate trustless, asynchronous model breeding, toolkits like MergeKit increasingly wrap the manifest schema in a Conflict-Free Replicated Data Type (CRDT)23. By structuring the distributed merging process via an OR-Set (Observed-Remove Set) CRDT, the contributions of independent actors become trivially commutative, associative, and idempotent at the set level23. The browser-local Rust verification system parses this CRDT state tree via a two-layer architecture:

1. Layer 1 (The CRDT Collection): Manages the set of available model contributions. Set union is mathematically conflict-free. The system validates the C2PA signatures of each contribution to eject spoofed or unauthorized updates23.
2. Layer 2 (The Deterministic Merge): Dictates the deterministic pure function (e.g., TIES, DARE) applied over the canonically ordered contribution set from Layer 1\. The randomness is seeded deterministically from the Merkle root of the collection23.

This architectural separation entirely resolves the non-determinism introduced by network latency and decentralized routing. Regardless of the chronological order in which a client node receives the weight updates, applying the pure merge functions outlined above over the unified CRDT set will mathematically guarantee a bit-exact identical Safetensors output24.

Conclusion

The transition from solitary AI model training to evolutionary model breeding represents a structural revolution in machine learning. By utilizing techniques such as DARE, TIES, Model Soups, and evolutionary crossover, the research community is realizing compounding improvements to Small Language Models without the environmental and financial costs of GPU-intensive pre-training2. However, these techniques inherently obscure the developmental path of the model8. Without a mechanism to mathematically prove lineage, parent compatibility, and fitness, the deployment of these bred models poses unacceptable systemic security risks in compliance-heavy or safety-critical environments8. By defining stringent metadata schemas—encompassing exact interpolation steps, deterministic PRNG configurations, magnitude ranking tie-breakers, and signed C2PA attestations—practitioners can securely map the genetic history of a neural network13. A browser-local Rust verification system, leveraging the byte-stability of Safetensors, the asynchronous synchronization of CRDTs, and Nondeterministic-tolerance Aware Optimistic (NAO) protocols, can parse these manifests to algorithmically prove the integrity of a model12. By integrating deterministic pure functions with hardware-aware tolerance bounds, this framework ensures that the open-source ecosystem can continue to aggressively breed and cross-pollinate intelligent models, backed by an immutable, cryptographically secure chain of custody.

Works cited

1. Model Merging in LLMs, MLLMs, and Beyond: Methods, Theories, Applications and Opportunities \- arXiv, https://arxiv.org/html/2408.07666v3
2. Daily Papers \- Hugging Face, https://huggingface.co/papers?q=evolutionary%20model%20merging
3. Model Merging in the Era of Large Language Models: Methods, Applications, and Future Directions \- arXiv, https://arxiv.org/html/2603.09938v1
4. (PDF) Evolutionary optimization of model merging recipes \- ResearchGate, https://www.researchgate.net/publication/388424127\_Evolutionary\_optimization\_of\_model\_merging\_recipes
5. Evolutionary Optimization of Model Merging Recipes \- arXiv, https://arxiv.org/html/2403.13187v2
6. The Model IS the Computer: What Compute-in-Memory Means for AI Deployment | AIXplore, https://ai.rundatarun.io/cutting-edge-ai/model-is-the-computer-compute-in-memory
7. Evolutionary Optimization of Model Merging Recipes \- arXiv, https://arxiv.org/html/2403.13187v1
8. Poisoned at the Source: Training Data Attacks, Model Supply Chain Risks, and the Open-Source AI Security Crisis | CISO Marketplace, https://cisomarketplace.com/blog/ai-model-supply-chain-training-data-poisoning-open-source-risk
9. AI Supply Chain Security: MBOM-PQC Provenance, PQC Attestation, and a Maturity Model for Quantum-Resistant Assurance \- MDPI, https://www.mdpi.com/2079-8954/14/5/593
10. GitHub \- Palash90/build-your-own-nn, https://github.com/Palash90/build-your-own-nn
11. Taming non-determinism: from logic gates to LLMs \- Leandro Proença, https://leandronsp.com/articles/taming-non-determinism-from-logic-gates-to-llms
12. AOSSIE-Org/OpenVerifiableLLM: Local Fully Open, Open-Weight, Open-Data, Verifiable LLMs \- GitHub, https://github.com/AOSSIE-Org/OpenVerifiableLLM
13. The 99% Problem: Why Git Thinks Your Fine-Tuned Model is Brand New | by Khushiyant, https://khushiyant.medium.com/the-99-problem-why-git-thinks-your-fine-tuned-model-is-brand-new-9f8cce727d96
14. Agent Memory Below the Prompt: Persistent Q4 KV Cache for Multi-Agent LLM Inference on Edge Devices \- arXiv, https://arxiv.org/html/2603.04428v1
15. What Is the C2PA Standard? How It Works and Its Limits \- TrueScreen, https://truescreen.io/articles/c2pa-standard-history-limitations/
16. C2PA and CAWG Standards Overview \- Trufo, https://trufo.ai/standards
17. Content Credentials : C2PA Technical Specification, https://spec.c2pa.org/specifications/specifications/2.4/specs/C2PA\_Specification.html
18. Authenticated Contradictions from Desynchronized Provenance and Watermarking \- arXiv, https://arxiv.org/html/2603.02378v1
19. Determinism for floating point operations in Rust \- help, https://users.rust-lang.org/t/determinism-for-floating-point-operations-in-rust/4426
20. How are deterministic games possible in the face of floating-point non-determinism?, https://gamedev.stackexchange.com/questions/14776/how-are-deterministic-games-possible-in-the-face-of-floating-point-non-determini
21. Nondeterminism-Aware Optimistic Verification for Floating-Point Neural Networks \- arXiv, https://arxiv.org/html/2510.16028v1
22. Usage of "non-deterministic" floating point operations is misleading · Issue \#150323 · rust-lang/rust \- GitHub, https://github.com/rust-lang/rust/issues/150323
23. Daily Papers \- Hugging Face, https://huggingface.co/papers?q=deterministic%20pure%20functions
24. mgillr/crdt-merge \- GitHub, https://github.com/mgillr/crdt-merge
25. I built a custom 2-Bit Ternary Inference Engine from scratch in Rust \+ native PyTorch QAT. I'm running GPT-2 XL (1.5B) entirely offline on a Surface Pro 7 at 115 tokens/sec. : r/LocalLLM \- Reddit, https://www.reddit.com/r/LocalLLM/comments/1tmu2ug/i\_built\_a\_custom\_2bit\_ternary\_inference\_engine/
26. Mergekit Model Merging | Guides \- Clore.ai, https://docs.clore.ai/guides/training/mergekit
27. Model Merging: A new way of creating model | by Sanjeev Bhandari, https://realsanjeev.medium.com/model-merging-a-new-way-of-creating-model-e62e6d14ef97
28. An Introduction to Model Merging for LLMs | NVIDIA Technical Blog, https://developer.nvidia.com/blog/an-introduction-to-model-merging-for-llms/
29. Experiment with LLM Model Merging Techniques | by Minyang Chen \- Medium, https://mychen76.medium.com/the-art-of-model-blending-and-moerges-bac7f3749ab7
30. LLM Merging Techniques Overview \- Emergent Mind, https://www.emergentmind.com/topics/llm-merging
31. Naphula/Cthulhu-70B-v1 \- Hugging Face, https://huggingface.co/Naphula/Cthulhu-70B-v1
32. Cryptographic Attestation for AI Model Lifecycle: From Training Data to Inference Output \- IETF Datatracker, https://datatracker.ietf.org/doc/draft-sharif-ai-model-lifecycle-attestation/00/
33. Model Merging: Combining Different Fine-Tuned LLMs \- Marvik.ai, https://www.marvik.ai/blog/model-merging-combining-different-fine-tuned-llms
34. TIES-Merging: Resolving Interference When Merging Models \- arXiv, https://arxiv.org/pdf/2306.01708
35. Can MLLMs Absorb Math Reasoning Abilities from LLMs as Free Lunch?, https://papers.nips.cc/paper\_files/paper/2025/file/bdcdf38389d7fcefc73c4c3720217155-Paper-Conference.pdf
36. TIES-Merging: Robust Model Integration \- Emergent Mind, https://www.emergentmind.com/topics/ties-merging
37. \[2406.11617\] DELLA-Merging: Reducing Interference in Model Merging through Magnitude-Based Sampling \- arXiv, https://arxiv.org/abs/2406.11617
38. Paper Explained: Language Models are Super Mario | by Minhajul Hoque \- Medium, https://medium.com/@minh.hoque/paper-explained-language-models-are-super-mario-2ebce6c2cf35
39. Paper Review TIES-MERGING: Resolving Interference When Merging Models \- Medium, https://medium.com/@kimseongu15/paper-review-ties-merging-resolving-interference-when-merging-models-88581ee56557
40. \[2605.29101\] Model Merging by Output-Space Projection \- arXiv, https://arxiv.org/abs/2605.29101
41. Merge Large Language Models. Combine Mistral, WizardMath and… | by Sergei Savvov \- Medium, https://slgero.medium.com/merge-large-language-models-29897aeb1d1a
42. ML2025 HW9 Model Merging, https://speech.ee.ntu.edu.tw/\~hylee/ml/ml2025-course-data/hw9.pdf
43. Leveraging Model Soups to Classify Intangible Cultural Heritage Images from the Mekong Delta \- arXiv, https://arxiv.org/pdf/2603.02181
44. Graph Ladling: Shockingly Simple Parallel GNN Training without Intermediate Communication \- arXiv, https://arxiv.org/pdf/2306.10466
45. Graph Ladling: Shockingly Simple Parallel GNN Training without Intermediate Communication \- Proceedings of Machine Learning Research, https://proceedings.mlr.press/v202/jaiswal23a/jaiswal23a.pdf
46. Instant Soup: Cheap Pruning Ensembles in A Single Pass Can Draw Lottery Tickets from Large Models \- Proceedings of Machine Learning Research, https://proceedings.mlr.press/v202/jaiswal23b/jaiswal23b.pdf
47. Model soups improve performance of dermoscopic skin cancer classifiers \- ResearchGate, https://www.researchgate.net/publication/362677596\_Model\_soups\_improve\_performance\_of\_dermoscopic\_skin\_cancer\_classifiers
48. Effective Multi-Modal and Multi-Domain Graph-Based Recommender Systems via Self-Supervised Learning \- Enlighten Theses, https://theses.gla.ac.uk/85783/3/2025YiPhD.pdf
49. 10 Data Provenance Patterns to Prove AI Training Sources On-Chain | by Quaxel \- Medium, https://medium.com/@Quaxel/10-data-provenance-patterns-to-prove-ai-training-sources-on-chain-a90570005cd7
50. Verifiable Inference Systems | AI & Blockchain \- Techfyte, https://techfyte.com/ai-blockchain-solutions/verifiable-inference-systems/
51. EvoMerge: Neuroevolution for Large Language Models \- arXiv, https://arxiv.org/html/2402.00070v1
52. Competition and Attraction Improve Model Fusion \- arXiv, https://arxiv.org/html/2508.16204v1
53. Model Merging and You, https://planetbanatt.net/articles/modelmerging.html
54. \[2403.13187\] Evolutionary Optimization of Model Merging Recipes \- arXiv, https://arxiv.org/abs/2403.13187
55. EvoGM: Learning to Merge LLMs via Evolutionary Generative Optimization \- arXiv, https://arxiv.org/html/2605.29295v1
56. The Comprehensive Guide to Fine-tuning LLM | by Sunil Rao | Data Science Collective, https://medium.com/data-science-collective/comprehensive-guide-to-fine-tuning-llm-4a8fd4d0e0af
57. A Simple and Effective Pruning Approach for Large Language Models \- OpenReview, https://openreview.net/forum?id=PxoFut3dWW
58. LLM Pruning on GPU Cloud: SparseGPT and Wanda for 50% Model Compression Without Retraining (2026) | Spheron Blog, https://www.spheron.network/blog/llm-pruning-sparsegpt-wanda-gpu-cloud/
59. Doing More With Less: Revisiting the Effectiveness of LLM Pruning for Test-Time Scaling, https://arxiv.org/html/2604.25098v1
60. Pruner-Zero: Evolving Symbolic Pruning Metric from scratch for Large Language Models, https://arxiv.org/html/2406.02924v1
61. A Simple and Effective Pruning Approach for Large Language Models \- Semantic Scholar, https://www.semanticscholar.org/paper/A-Simple-and-Effective-Pruning-Approach-for-Large-Sun-Liu/7d22ad3573101337bca2091fb0114b377c4f3db6
62. Effective Model Pruning | OpenReview, https://openreview.net/forum?id=kx3txPrC2B
63. SeedLoRA: A Fusion Approach to Efficient LLM Fine-Tuning \- GitHub, https://raw.githubusercontent.com/mlresearch/v267/main/assets/liu25o/liu25o.pdf
64. Adaptive LoRA Fusion \- Emergent Mind, https://www.emergentmind.com/topics/adaptive-lora-fusion
65. qa-FLoRA: Data-free query-adaptive Fusion of LoRAs for LLMs \- arXiv, https://arxiv.org/html/2512.11366v1
66. qa-FLoRA: Data-free query-adaptive Fusion of LoRAs for LLMs, https://ojs.aaai.org/index.php/AAAI/article/view/40581/44542
67. Understanding Sakana.ai's Evolutionary Model Merging | Paper Notes, https://en.bioerrorlog.work/entry/sakana-ai-model-merging-paper
68. ICML Poster MERGE$^3$: Efficient Evolutionary Merging on Consumer-grade GPUs, https://icml.cc/virtual/2025/poster/43950
69. mergekit/docs/create\_a\_merge\_method.md at main · arcee-ai, https://github.com/arcee-ai/mergekit/blob/main/docs/create\_a\_merge\_method.md
70. Arcee's MergeKit: A Toolkit for Merging Large Language Models \- arXiv, https://arxiv.org/html/2403.13257v2