Papers
Topics
Authors
Recent
Search
2000 character limit reached

WARP: Weight-Space Analysis for Recovering Training Data Portfolios

Published 2 Jul 2026 in cs.LG | (2607.01686v1)

Abstract: Foundation models are routinely released to the public, yet the data recipes used to train them -- such as domain mixture weights that determine how different sources are sampled -- are rarely disclosed. This creates an access asymmetry: researchers study the resulting models but lack visibility into the training distribution that produces them. Prior works for inferring training data, such as membership inference, detect at the level of individual samples and thus cannot characterize the global composition of the training corpus. We introduce WARP, a framework that recovers a fine-tuned model's training mixtures directly from its released weights. WARP interpolates between the base and fine-tuned models using model merging, generating pseudo-checkpoints that approximate the missing training trajectory and expose a geometric footprint of the training data in the weight space. From these simulated footprints, WARP extracts geometric features and maps them to domain proportions using either a parameter-free softmax readout or an MLP projector trained on synthetic mixtures. In controlled experiments with BERT and GPT-2, WARP recovers domain mixtures with an average MAE as low as 0.046 and 0.104 respectively, outperforming membership inference and a variant with access to the true training trajectory.

Summary

  • The paper introduces WARP, which recovers a fine-tuned model's domain mixture using weight-space interpolation between base and reference weights.
  • It leverages geometric footprint extraction via gradient alignment from pseudo-checkpoints to map training data portfolios.
  • The method demonstrates low mean absolute error on BERT and GPT-2, outperforming sample-level membership inference baselines.

Weight-Space Analysis for Recovering Training Data Portfolios: An Expert Summary

Problem Setting and Motivation

The proliferation of foundation models has led to an inversion of the classical paradigm: model weights are routinely released, but the data mixtures used to fine-tune these models remain proprietary and undisclosed. This opacity presents a data recipe/model access asymmetry, which constrains research on data-centric optimization, auditing for contamination, and interpretability. The standard direction in data mixture optimization—deriving an optimal sampling policy and then training the model—cannot reconstruct the original mixture from the trained weights. Prior work in membership inference only tests inclusion at the level of individual samples and provides no aggregate visibility into the underlying data mixture proportions across domains. Figure 1

Figure 1: The forward problem optimizes training mixture π to produce model weights θ; the inverse problem seeks to recover domain mixture π given only baseline and reference weights.

The WARP Framework

WARP (Weight-space Analysis for Recovering Training Data Portfolios) targets this inverse problem: recovering a fine-tuned model's domain mixture π\pi^* from released weights θref\theta_{\text{ref}} and the associated base model θbase\theta_{\text{base}}, using only a small probing dataset with labeled examples from the constituent domains. The key premise is that the global geometry of the model's weight-space evolution encodes a footprint of the data mixture. However, as only endpoints (start and finish of fine-tuning) are available, WARP leverages model merging/interpolation techniques to synthesize pseudo-checkpoints along plausible trajectories between θbase\theta_{\text{base}} and θref\theta_{\text{ref}}.

The WARP pipeline decomposes as follows:

  1. Trajectory Simulation: Pseudo-checkpoints are constructed via linear, spherical, or advanced merging (e.g., TIES) operators between the base and reference weights. This defines a sequence of interpolated models {θ~t}\{\tilde{\theta}_t\} as proxies for training progression.
  2. Geometric Footprint Extraction: At each pseudo-checkpoint, gradients of probing samples are projected onto the vector from the current checkpoint to θref\theta_{\text{ref}}. This "Mimic Score" quantifies how each domain's data would have advanced the model along the actual fine-tuning direction.
  3. Mixture Prediction: Aggregated per-domain, per-step footprint matrices are mapped to mixture estimates via either (a) a label-free softmax readout or (b) a supervised MLP projector learned by constructing synthetic mixture–footprint pairs. Figure 2

    Figure 2: WARP simulates the unobserved trajectory via model merging, measures gradient alignment via Mimic Scores, then maps the geometric footprint to a predicted domain mixture.

Experimental Methodology and Results

Controlled experiments are conducted on BERT-base and GPT-2-small fine-tuned over known mixtures from diverse text classification datasets (SNLI, AGNews, Yelp, Yahoo), allowing quantitative measurement of mixture recovery error. For each run, the reference model is fine-tuned under a sampled mixture; probing sets are drawn separately.

Mixture recovery performance, measured as mean absolute error (MAE) between predicted and true mixtures, demonstrates that WARP's weight-space geometric approach offers a strong and robust signal. The supervised 2-layer MLP variant achieves MAE as low as 0.046 on BERT and 0.104 on GPT-2, outperforming strong sample-level membership inference baselines by significant margins. Notably, even the unsupervised (parameter-free) softmax readout is competitive and frequently outperforms baselines.

An important empirical finding is that interpolated (simulated) checkpoint sequences match or even outperform oracle variants using saved real fine-tuning checkpoints. This suggests that model merging creates smoother, more predictable trajectories, facilitating easier readout of the data footprint.

Across multiple checkpointing policies (early, converged, overtrained), WARP's mixture estimates remain robust, highlighting the method's applicability to practical settings where the exact stopping point of fine-tuning is uncontrolled.

Implications and Theoretical Significance

WARP provides formalization and methodology for an inverse mapping from model weights to training domain mixtures, exploiting weight-space geometry as a persistent trace of the training recipe. This approach goes beyond the limitations of sample-level membership inference by identifying global data portfolio structure, allowing for:

  • Auditing: Checking released models for contamination or unwanted domain emphasis given only probe sets and endpoints.
  • Interpretability: Inferring why a model might display domain-specific behavior post hoc.
  • Transparency: Enhancing reproducibility and scrutiny in situations where training data cannot be shared.

Additionally, the finding that interpolation-based trajectories in weight-space (LERP, SLERP, TIES) serve as effective surrogates for unlogged fine-tuning paths has implications for other forms of weight-space analysis, potentially informing future diagnostic, attribution, and editing tools.

Limitations and Future Directions

While WARP is validated on moderate-sized transformer architectures and a controlled number of domains, scaling to multi-stage, curriculum-based LLM training and to much larger domain taxonomies remains an open challenge. The interpretability of the learned mapping from geometric footprints to mixtures deserves further analysis, as does the potential for fully unsupervised readouts with more sophisticated, adaptive aggregation mechanisms. Extension to settings where only partial domain-decomposable probe sets are available is another avenue for development.

Conclusion

WARP demonstrates that weight-space geometric analysis, augmented by model merging, enables accurate and robust recovery of a model's data mixture from accessible endpoints. This provides a foundation for transparency and post hoc auditing of large models in environments where training data access is asymmetrical. The approach presented opens new theoretical and practical directions for backward inference on foundation models, leveraging the persistent traces of data curation decisions embedded in the weight space.

(2607.01686)

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

Explaining “WARP: Weight-Space Analysis for Recovering Training Data Portfolios”

What is this paper about? (Overview)

This paper introduces WARP, a method to figure out what kinds of data a LLM was trained on—and in what proportions—by looking only at the model’s “weights” (its internal settings). Companies often release models but keep their training data secret. WARP tries to reduce that secrecy by estimating how much of each data type (like news, reviews, or math text) went into the model’s fine‑tuning recipe.

What questions does the paper try to answer?

  • If we only have a base model and its fine‑tuned version, can we estimate the mix of training data types (the “domain mixture”) used to fine‑tune it?
  • Can we do this better than older methods that focus on single examples (membership inference), which don’t tell us overall proportions?
  • Can we recover those proportions accurately without having the real training checkpoints (the saved states during training)?

How does WARP work? (Simple explanation with an analogy)

Think of a model’s weights as millions of tiny knobs on a giant control board. Training is turning those knobs from their starting positions (the base model) to new positions (the fine‑tuned model). The path taken during training is usually not shared.

WARP’s idea is:

  1. Simulate the journey:
    • We have only the start (base) and finish (fine‑tuned). WARP creates a set of “in‑between” models by smoothly blending the two sets of knobs. These are called “pseudo‑checkpoints.” This step uses model merging methods like simple linear blending (LERP), spherical blending (SLERP), or a smarter blend called TIES.
  2. Measure how different data types “push” the model:
    • Take a small “probing” dataset where each example’s domain is known (e.g., news vs. reviews). For each pseudo‑checkpoint, WARP computes how each example would nudge the model’s knobs if we trained on it for a moment. This nudge is called a “gradient,” and WARP asks: does this example’s nudge move the model toward the final fine‑tuned model?
    • That “how well do you push in the right direction?” score is called a Mimic Score. Higher scores suggest that type of data was more important during fine‑tuning.
  3. Summarize by domain and read out the mixture:
    • WARP averages these scores for each domain across the pseudo‑checkpoints, creating a “footprint” that shows how each domain aligns with the path toward the final model.
    • Then it converts that footprint into estimated proportions in two ways:
      • A simple, label‑free method: average and apply a softmax (a squashing function that produces a probability‑like distribution).
      • A learned method: train a small neural net (an MLP) on synthetic examples (short, cheap practice fine‑tunes with known mixtures) so it learns to map footprints to mixture percentages.

In short: WARP fakes the missing training path, checks which kinds of data push in the same direction as that path, and then turns that signal into a guess of the original data mix.

What did the researchers find, and why is it important?

Across controlled tests, the authors created fine‑tuned versions of BERT and GPT‑2 using known mixtures from four datasets (SNLI, AGNews, Yelp, Yahoo). Then they asked if WARP could recover those known mixtures:

  • Accuracy:
    • With BERT, WARP reached an average error as low as 0.046 (MAE).
    • With GPT‑2, WARP reached an average error as low as 0.104 (MAE).
  • Better than older approaches:
    • WARP outperformed membership inference methods, which focus on whether a specific example was in training and don’t reliably capture overall proportions.
  • Surprisingly, simulating the path can be enough—or even better:
    • The versions of WARP that used simulated “in‑between” models sometimes beat a version that had access to real training checkpoints. The authors suggest the simulated paths are smoother and cleaner, making the signal easier to read.
  • Robustness:
    • WARP worked well whether the final model was early‑stopped, fully converged, or even overtrained, which matches how models are often released in the real world.

Why this matters:

  • Transparency: It offers a way to peek into a model’s “data DNA” when the actual recipe is hidden.
  • Safety and quality: Knowing data proportions can help detect contamination (e.g., copyrighted or overly repeated material) and explain odd behaviors.
  • Practicality: It uses artifacts you often have (the base and fine‑tuned weights) plus a small probing set.

What could this research change in the future? (Implications)

  • Auditing models: Regulators, researchers, and users could better understand what kinds of data shaped a model’s behavior.
  • Better fine‑tuning: If you know the original mix, you can fine‑tune more safely without pushing the model too far in one direction.
  • Data governance: Tools like WARP might encourage more responsible data use, because it becomes harder to hide problematic training mixtures.
  • Research foundations: It shows that “weight‑space geometry” (the pattern of how weights move) stores clues about training data, opening doors for other reverse‑engineering tools that promote transparency.

Overall, WARP is like a detective for model training: it uses only the start and end “photos” of training, recreates a believable path between them, and reads the footprints left behind to guess the training data recipe.

Knowledge Gaps

Below is a concise list of concrete knowledge gaps, limitations, and open questions that remain unresolved in the paper. These highlight what is missing, uncertain, or unexplored, and can guide future research.

  • Reliance on known base model: How to recover mixtures when the exact base model used for fine-tuning is unavailable or uncertain (e.g., only an instruction-tuned or RLHF model is released, or the base is proprietary)?
  • Domain coverage assumption: How to handle open-world settings where the released model’s training data contains domains not represented in the probing set or where domain taxonomies are unknown or mismatched?
  • Probe construction requirements: What is the minimal size, quality, and domain-label fidelity of the probing dataset needed for reliable recovery, and how sensitive is WARP to mislabeled or noisy domain tags?
  • Compute and memory cost: The method requires per-sample gradients at multiple pseudo-checkpoints. What are the practical compute/memory costs for larger models, and can gradient approximations (e.g., layer-wise, low-rank, Fisher-diagonal, or influence-function proxies) preserve accuracy?
  • Scaling to large LLMs: Does performance and stability hold for multi-billion parameter models, where curvature, parameter symmetries, and optimizer dynamics are more pronounced?
  • Sensitivity to merging operator choice: How robust are results to different merging methods (LERP, SLERP, TIES, rebasin/permutation alignment), and what operator- and schedule-selection criteria optimize mixture recovery?
  • Hyperparameter sensitivity: How do the number of interpolation steps T, interpolation schedules, normalization choices (e.g., min–max vs z-score), and softmax temperature τ affect estimation stability and bias?
  • Theoretical guarantees: Is there a formal relationship between the Mimic Score–based geometric footprint and true domain mixture, including identifiability conditions and error bounds under model/data assumptions?
  • Path curvature and nonlinearity: Linear/spherical merges approximate a path; how does trajectory curvature in weight space (and loss landscape geometry) bias the footprint and mixture estimates?
  • Dynamic mixing schedules: Can WARP recover time-varying mixture schedules (curriculum or online reweighting) instead of static proportions, and what changes are needed to the footprint or projector?
  • Objective mismatch: How does WARP perform when the fine-tuning objective differs (e.g., instruction tuning, RLHF, contrastive, or multi-task losses), and can it disentangle domain mixture from objective-induced weight changes?
  • Adapter- and low-rank fine-tuning: Does WARP remain effective when only adapters/LoRA deltas are released, or when the reference has quantized/merged weights, EMA, or model soups?
  • Architecture compatibility: What breaks when the fine-tuned model changes architecture or tokenizer relative to the base (e.g., added adapters, expanded vocab), and can WARP be adapted?
  • Bias from heterogeneous gradient norms: Since domains can induce different gradient magnitudes, how much does this bias the Mimic Score aggregation, and can normalization or variance-correction reduce bias?
  • Layer- and module-wise footprints: Would layer-wise or module-wise weighting of geometric features (or attention to specific blocks) improve mixture recovery and diagnostic interpretability?
  • Uncertainty quantification: How to provide confidence intervals or Bayesian posteriors over mixture estimates, especially when probe sizes are small or domain overlap is high?
  • Robustness to defenses/obfuscation: How do noise injection, weight permutation/randomization, checkpoint smoothing, or sparsification defenses affect WARP’s success, and can robust estimators be designed?
  • Handling domain overlap and ambiguity: Real corpora have fuzzy, overlapping domains; can WARP recover mixtures over continuous or hierarchical domain taxonomies, or detect ambiguous data regions?
  • Probe-domain discovery: If domain labels are unavailable, can WARP be extended to discover latent domains from weight-space geometry and jointly estimate mixtures?
  • Cross-dataset generalization: How well do projectors trained on synthetic mixtures from one source transfer to models fine-tuned on related but different sources or distributions?
  • Practicality of supervised variant: The supervised MLP requires multiple synthetic fine-tunes. What is the true cost–benefit trade-off, and can meta-learning or amortized simulators reduce fine-tune overhead?
  • Baseline breadth: The paper mainly contrasts with membership inference. How does WARP compare against other dataset inference approaches (e.g., influence functions, representation-space probes, Shapley-based data valuation)?
  • Large-K regimes: Performance is evaluated up to K=10; how does accuracy and sample complexity scale with hundreds of domains typical in web-scale mixtures?
  • Partial-information settings: Can WARP incorporate weak prior knowledge (e.g., known absence of certain domains, coarse bounds) to improve estimates, and how robust is it to prior misspecification?
  • Choice of loss for gradients: For generative LMs, per-token cross-entropy gradients could be used; how do tokenization strategy, sequence length, and prompt format affect the footprint and recovery quality?
  • Normalization choices: The method uses per-step min–max normalization of Mimic Scores; are there principled alternatives (e.g., robust, domain-wise, or variance-aware) that reduce sensitivity to outliers?
  • Release-layer perturbations: How do common release-time changes (e.g., additional safety fine-tunes, RLHF passes, or DPO) compounded atop the original mixture affect identifiability of the base mixture?
  • Ethical and policy implications: WARP may reveal proprietary or sensitive data recipes. What are guidelines for responsible use, and can mechanisms offer controllable transparency (auditing) without full disclosure?
  • Failure mode diagnosis: When mixture recovery fails, how to attribute errors to probe mismatch, merging approximation, gradient noise, or model non-identifiability—and can diagnostics guide remedial actions?
  • Multimodal extension: Can WARP be extended to multimodal models (vision–language, code, audio), where gradients and mixing span heterogeneous modalities and objectives?

Practical Applications

Summary

The paper introduces WARP, a weight-space method to infer the domain mixture (training data portfolio) used to fine-tune a released model, using only the base weights, the fine-tuned weights, and a small labeled probing dataset spanning the target domains. It simulates a training trajectory via model merging (LERP/TIES), computes domain-level geometric “footprints” using Mimic Scores (gradient alignment to the base→ref direction), and maps those footprints to mixture estimates via either a parameter-free softmax or a small MLP trained on synthetic mixtures. In controlled studies with BERT and GPT-2, WARP recovers mixtures more accurately than membership inference baselines and remains robust across early-stop, converged, and overtrained checkpoints.

Below are actionable applications that flow from these findings and methods.

Immediate Applications

These applications can be deployed now with access to base and fine-tuned weights, a small labeled probe set across relevant domains, and standard ML tooling.

  • Industry-wide model data-portfolio auditing
    • What: Generate a “Data Nutrition Label” that estimates a model’s training mixture across domains (e.g., web/news/code/science; languages/dialects; license categories).
    • Sectors: Software/AI, model vendors, open-source communities.
    • Tools/products/workflows: “WARP Auditor” CLI/SDK; CI step producing mixture bar charts, confidence intervals, and drift alerts; integration with MergeKit/TIES for pseudo-checkpoints.
    • Assumptions/dependencies: Access to both base and fine-tuned weights; probe set spans the domain taxonomy of interest; ability to compute per-sample gradients at pseudo-checkpoints; mixture estimates are approximate and depend on probe quality.
  • Fine-tuning planning and prevention of capability drift
    • What: Measure the current model’s domain exposure before continued fine-tuning; reweight data or add targeted domains to avoid unwanted drift and improve sample efficiency.
    • Sectors: Software, enterprise MLOps.
    • Tools/workflows: “Mixture Monitor” gate in MLOps pipelines; automatic reweighting recommendation (“AutoMix Reweighter”) informed by WARP’s unsupervised readout for quick wins.
    • Assumptions/dependencies: Clear mapping from business domains to probe domains; stable access to future fine-tuning data.
  • Data contamination and test leakage screening
    • What: Detect overrepresentation of suspect domains (e.g., benchmark/test bank content, proprietary corpora) in a fine-tuned model.
    • Sectors: Education (exam banks), research/benchmarking, media.
    • Tools/workflows: “Contamination Scanner” using targeted probe sets (e.g., benchmark subsets, proprietary corpora fingerprints) to flag elevated mixture proportions.
    • Assumptions/dependencies: Probe set must accurately reflect the sensitive/test domains; mixture inference is domain-level (not per-item membership).
  • Vendor due diligence and procurement checks
    • What: Verify third-party claims about training data composition for commercial or regulated deployments; attach a distribution estimate to RFP submissions.
    • Sectors: Government, finance, healthcare, enterprise IT procurement.
    • Tools/products/workflows: “Distribution Card” generator and report; third-party audit service built on WARP.
    • Assumptions/dependencies: Contractual allowance to inspect weights; sector-specific probe sets (e.g., clinical notes vs. general web, regulated document categories).
  • License compliance checks for code models
    • What: Estimate proportions of code licenses (e.g., GPL, permissive) in a model’s training mix to inform commercialization risk.
    • Sectors: Software, legal/compliance.
    • Tools/workflows: “License Mix Auditor” using a probe set with license labels (e.g., curated Git repos).
    • Assumptions/dependencies: Accurate license labels in probe data; code-model-compatible loss for gradient computation.
  • Language, locale, and demographic balance auditing
    • What: Quantify language/dialect/locale proportions to assess fairness, coverage, and localization readiness.
    • Sectors: Global consumer apps, public-sector services.
    • Tools/workflows: “Locale Bias Card” with per-language mixture estimates; procurement checklist for multilingual readiness.
    • Assumptions/dependencies: Probe set coverage across languages/dialects; chosen loss captures differences (e.g., LM loss for generative models).
  • Academic replication and benchmark calibration
    • What: Approximate training mixtures for released checkpoints to interpret results, reproduce studies more faithfully, and build stronger baselines.
    • Sectors: Academia, research labs.
    • Tools/workflows: WARP unsupervised softmax readout (label-free and fast) to triage many checkpoints; detailed follow-up with supervised MLP if needed.
    • Assumptions/dependencies: Reasonable proxy probe datasets for the studied domains.
  • Model selection and merging strategy
    • What: Choose complementary models for merging or ensembling based on non-overlapping or targeted mixtures; reduce redundancy.
    • Sectors: Software/AI, platform teams.
    • Tools/workflows: “Merge Planner” that ranks candidate pairs by complementary mixture profiles before running model soups/merging.
    • Assumptions/dependencies: Comparable architectures or supported merging strategies (LERP/TIES); access to weights.
  • Competitive analysis for open-weight models
    • What: Infer a competitor’s training focus (e.g., heavy code or math emphasis) to inform product strategy.
    • Sectors: Software/AI.
    • Tools/workflows: One-off WARP audit with sector-specific probe sets (code/math/instruction).
    • Assumptions/dependencies: Open weights; ethical/legal considerations in analysis and disclosure.
  • Post-training auditing (SFT/RLHF pipelines)
    • What: Quantify the SFT mixture prior to RLHF or safety tuning to contextualize emergent behaviors and guide red-teaming.
    • Sectors: Safety, trust & safety teams.
    • Tools/workflows: WARP run per stage (base→SFT; SFT→RLHF adapter) to produce staged Distribution Cards.
    • Assumptions/dependencies: For RLHF-only adapters, use the SFT checkpoint as “base” and the RLHF-adapted model or adapters as “ref”.

Long-Term Applications

These require further research, standardization, scale-up, or ecosystem support.

  • Regulatory transparency and standards: Training Distribution Cards
    • What: Standardized “Distribution Cards” disclosing estimated domain mixtures alongside model releases, complementing Model Cards and Data Cards.
    • Sectors: Cross-sector; regulators (e.g., EU AI Act), standards bodies.
    • Tools/workflows: Certification pipelines; third-party attestation services using WARP or successors.
    • Assumptions/dependencies: Consensus on domain taxonomies; accepted error bars; governance frameworks.
  • Provenance and mixture watermarking
    • What: Embed robust, verifiable “mixture signatures” during training; use weight-space auditors as verifiers for provenance and anti-laundering.
    • Sectors: Data markets, IP enforcement.
    • Tools/workflows: Watermarking schemes co-designed with WARP-like verifiers.
    • Assumptions/dependencies: New methods to make signatures robust to fine-tuning/merging; legal acceptance.
  • Closed-loop data-mixing controllers during training
    • What: Real-time feedback from weight-space geometry to dynamically reweight domains (integrating with DoReMi/Aioli-style systems).
    • Sectors: Foundation model pretraining, large-scale mid-training.
    • Tools/workflows: “Mixture Controller” that queries WARP-like readouts periodically and updates sampling policies online.
    • Assumptions/dependencies: Efficient large-scale gradient sampling; engineering for frontier-scale runs.
  • Data-market contracts and verification
    • What: Contracts priced by delivered mixture composition (“pay for mix”), verified by auditors.
    • Sectors: Data brokers, enterprise buyers.
    • Tools/workflows: Audit APIs; escrow-linked verification reports.
    • Assumptions/dependencies: Reference probe sets accepted by both parties; clear tolerance bands.
  • Safety and risk forecasting from mixtures
    • What: Map domain proportions (e.g., bio, cyber, code, weapons manuals) to hazard likelihood and capability forecasts; gate releases accordingly.
    • Sectors: Responsible AI, national security.
    • Tools/workflows: Risk curves trained from incident data and evals; WARP provides input features.
    • Assumptions/dependencies: High-quality risk datasets; calibrated models linking mixture to risk; governance buy-in.
  • Privacy-preserving, enclave-based audits
    • What: Run mixture inference in secure enclaves for sensitive or proprietary weights; emit attested summaries only.
    • Sectors: Regulated industries, cloud providers.
    • Tools/workflows: TEEs/SMPC; audit attestation services.
    • Assumptions/dependencies: Enclave performance for gradient computations; trust infrastructure.
  • Multimodal and robotics extensions
    • What: Extend weight-space mixture recovery to vision/audio/robotics (domains = sensor types, environments, sim vs. real).
    • Sectors: Autonomous systems, AR/VR, industrial robotics.
    • Tools/workflows: Modality-appropriate probe sets; merging and loss definitions for multimodal encoders/policies.
    • Assumptions/dependencies: Effective multimodal merging; per-sample gradient access and losses beyond text.
  • API-only or adapter-limited models
    • What: Adapter-level WARP (e.g., LoRA deltas) when full weights are unavailable; partial mixture inference for hosted models.
    • Sectors: SaaS LLMs.
    • Tools/workflows: “Adapter Auditor” operating on trainable parameter subsets/deltas.
    • Assumptions/dependencies: Provider exposes adapters or deltas; method robustness to partial parameter views.
  • Longitudinal governance: mixture registries
    • What: Track mixture drift over model versions; public registries of mixture evolution and associated incidents.
    • Sectors: Oversight labs, civil society.
    • Tools/workflows: Versioned Distribution Cards; dashboards tracking shifts and interventions.
    • Assumptions/dependencies: Community adoption; stable, comparable probe sets over time.
  • Tooling ecosystem and acceleration
    • What: Turn-key libraries, standardized probe suites, and hardware acceleration for per-sample gradients at scale.
    • Sectors: MLOps, cloud providers.
    • Tools/workflows: Hugging Face integrations; curated probe packs (license, language, safety domains); GPU kernels for batched per-sample gradients.
    • Assumptions/dependencies: Community-maintained probe datasets; engineering to reduce cost and memory for frontier models.

Notes on feasibility and dependencies across applications:

  • Access: Requires base and fine-tuned weights; closed API-only models are out of scope unless adapters/deltas are available.
  • Probe design: Accuracy depends on a probe set that adequately covers the true domains of interest; mis-specified or imbalanced probes degrade estimates.
  • Loss/gradients: Needs per-sample gradients under a meaningful loss (LM loss for generative models; classification loss for classifiers). For RLHF-only stages, use the SFT or LM loss as a proxy.
  • Merging quality: Better merging (e.g., TIES, re-basin) improves pseudo-trajectory fidelity; quantized weights may require dequantization or adapter-focused analysis.
  • Scale: Supervised projector requires synthetic fine-tunes (short runs suffice); when compute is limited, the unsupervised softmax readout provides a strong, deployable baseline.

Glossary

  • Compute-optimal budgets: Training budgets that theoretically minimize loss for a given compute scale; exceeding them can lead to inefficiency without gains. "mirroring today's post-training regime, where released models are routinely pushed beyond compute-optimal budgets"
  • Data contamination: Presence of training data in evaluation or unintended sources, leading to inflated performance or privacy/copyright issues. "useful for auditing data contamination"
  • Data portfolio: The composition of datasets or domains used to train a model, often with specific mixture proportions. "recovering a model's data portfolio is useful for auditing data contamination"
  • Domain mixture: The proportion in which data from different domains is combined for training. "One primary determinant of a model's ultimate capability is its domain mixture"
  • Domain mixture optimization: Methods to choose or adjust domain weights to improve training efficiency and performance. "domain mixture optimization"
  • Foundation models: Large, general-purpose models pre-trained on broad data and adaptable to many tasks. "Foundation models are trained on massive, heterogeneous corpora"
  • Geometric footprint: The imprint of training data on the model’s weight-space trajectory, revealing domain influence. "expose a geometric footprint of the training data in the weight space"
  • Gradient-alignment matrix: A matrix capturing alignment of gradients across domains to guide dynamic data reweighting. "by constructing a gradient-alignment matrix (R{paper_content}B)"
  • Linear interpolation (LERP): Straight-line interpolation between two parameter vectors in weight space. "SLERP (spherical interpolation), LERP (linear interpolation), and TIES"
  • Membership Inference (MI): Attacks or analyses to determine if a specific sample was included in a model’s training set. "has traditionally been framed as Membership Inference (MI)"
  • Mimic Score: A metric measuring how a sample’s gradient aligns with a preferred direction in weight space, indicating its training utility. "The Mimic Score~\citep{huang2025evaluating} measures how well a sample's negative gradient aligns with a direction in the weight space"
  • MLP projector: A small neural network (multi-layer perceptron) that maps geometric features to predicted domain mixtures. "an MLP projector trained on synthetic mixtures"
  • Model merging: Combining model weights (e.g., via interpolation or specialized algorithms) to fuse capabilities or simulate paths. "we use model merging techniques to interpolate between the base and fine-tuned models"
  • Multi-armed bandit problem: A sequential decision framework for allocating samples or weights to maximize reward, used here for dynamic data mixing. "casting data mixing as a multi-armed bandit problem"
  • Oracle variant: An evaluation setup that has privileged access (e.g., real intermediate checkpoints) to provide an upper bound or comparison. "we further include an oracle variant of WARP"
  • Probability simplex: The set of nonnegative vectors that sum to one, representing valid mixtures or probability distributions. "where ΔK1\Delta^{K-1} is the probability simplex."
  • Probing dataset: A small, labeled dataset sampled from the same source as training data, used to analyze or infer properties of the trained model. "and a small probing dataset"
  • Pseudo-checkpoints: Artificially constructed parameter states between base and fine-tuned models that approximate the missing training path. "generating pseudo-checkpoints that approximate the missing training trajectory"
  • SLERP (spherical interpolation): Interpolation along a great-circle arc between two points on a hypersphere in parameter space. "SLERP (spherical interpolation), LERP (linear interpolation), and TIES"
  • Softmax readout: A parameter-free or simple mapping that applies softmax to aggregated scores to estimate a domain mixture. "using either a parameter-free softmax readout or an MLP projector"
  • TIES (merging): A specific model-merging method designed to resolve interference when combining models. "SLERP (spherical interpolation), LERP (linear interpolation), and TIES"
  • Training trajectory: The sequence of parameter states a model passes through during training or fine-tuning. "a variant with access to the true training trajectory"
  • Weight-space geometry: The structure and relationships of model parameter vectors, used to infer training data characteristics. "using weight-space geometry, the one artifact always available, to recover insights"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 3 tweets with 156 likes about this paper.