Papers for

data platform teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Agentic system for better dataset search improves machine learning training

From Intent to Improvement: Agentic Dataset Search for Better Model Training

Abstract: Finding training data in million-scale machine learning repositories is a Web search problem where text relevance is not enough. A query couples a semantic training goal with constraints such as task, license, and training stage, and the metadata that would verify them are often missing. Text retrieval ranks dataset cards by similarity but cannot enforce hard constraints or follow the relations that reach a sparsely described dataset. Free-form tool-calling agents are more flexible, but the same model that picks a dataset also declares it a match, and nothing checks that the query's constraints are actually met. Neither approach establishes that the data it returns will improve model training. To address it, we propose AgenticDS, a contract-governed agentic framework in which every language model decision instantiates a typed object before deterministic code consumes it. The framework compiles a query into a typed search plan, executes it through admissible deterministic operators over hybrid retrieval and bounded graph expansion, and verifies the provenance-grounded evidence before accepting a ranking or emitting a typed diagnosis that permits only local repairs. On HuDS-Bench, a new benchmark of 200 queries with 24,908 graded judgments pooled over 15 systems, AgenticDS improves NDCG@10 by 25.7\% over the strongest dense--sparse hybrid and by 18.9\% over a commercial LLM agent. A controlled search-to-train study further shows that the datasets it retrieves give the best downstream accuracy in mathematics, code, and medicine. Code and data are publicly available at https://github.com/nju-websoft/AgenticDS.

Thu 29 OctArtificial IntelligenceInformation Retrieval
The gist
Finding the right data to train machine learning models is hard because many data collections online lack clear descriptions or important details. The authors designed AgenticDS, a new method that carefully checks the meaning and requirements of your search before picking datasets. It uses clear rules and verifying steps to make sure the chosen data really matches your needs and can improve model training. Tests show AgenticDS finds better datasets than other methods and helps models perform better in math, programming, and medical tasks.
Open → 2610.39608v1

Choosing near-duplicate images transfers preferences to vision-language models

Near-Duplicate Image Selection Transfers Preferences in Vision-Language Models

Abstract: Subliminal learning is the phenomenon in which a model transmits its preferences to another model through data that do not explicitly express them. As models increasingly curate training data for other models, we ask whether this transfer can arise from choosing among near-duplicate images while keeping the source photographs and human-written captions fixed. For each photograph, a curator selects one of eight near-duplicate variants by caption likelihood, without target-specific prompts. Students trained on target-preferring curators' selections show higher mean target-versus-alternatives log-likelihood ratios in an image-free readout than students trained on neutral selections. Under a prespecified decision rule, this directional shift appears for an owl target in LLaVA-1.5, Qwen2.5-VL, Qwen3-VL, and Gemma 4, with curators and students initialized from the same base checkpoint, and target rotations move it toward camels, oak trees, and a political figure. The owl target-selected student also scores above all count-matched random-reselection students in three models and above 55 of 60 in LLaVA-1.5, and Qwen3-VL shows the shift again on a new source bank with newly trained curators. Its size depends on dataset size, learning rate, and training budget; greedy choices among the eight options move toward the target by 10.4 percentage points in Qwen3-VL and 0.5-1.3 points elsewhere. First-generation students also pass the owl preference to a second generation through captions without explicit owl mentions in LLaVA-1.5 and Qwen3-VL. Thus even a deduplication-style choice among near-identical copies can shift students' target-relative readouts with source photographs and captions fixed; the tested linear probes classify the selecting arm with accuracies up to 59.7% (chance 50%).

Tue 20 OctMachine Learning
The gist
This paper shows that picking nearly identical versions of the same images can influence what an AI model learns to prefer, even when the pictures and captions don’t change. The authors trained models that selected certain image variants and found that later models trained on those selections inherited these subtle preferences. This effect happens without explicitly telling the models what to prefer and can even be passed on through multiple training rounds. So, even small changes in data selection can quietly shape model behaviors.
Open → 2610.27943v1

Optimal sample size needed for stable and accurate binary prediction

The Optimal Sample Complexity of Pointwise Replicable Agnostic Learning

Abstract: Pointwise replicability asks that two independently trained predictors, using the same random seed, agree at each fixed query with high probability. We determine its optimal agnostic sample complexity on finite and countable domains. For every nonempty binary class of finite VC dimension $d\ge1$, the required number of independent examples is $Θ\!\left(\frac{d}{ρ^2α^2}+\frac{\log(1/β)}{α^2}\right)$, uniformly over independent accuracy, failure, and disagreement parameters $α,β,ρ\in(0,1/10)$. The learner returns one binary function, may be improper, and uses unrestricted shared randomness. Its sample budget is fixed before observing data, and the replicability guarantee includes queries of zero marginal mass. The main construction combines an ensemble of empirical-risk minimizers with a smooth, signal-dependent risk decomposition. A single shared phase selects the final binary predictor. Record times certify its weak-signal risk, while a uniform bound protects the strong-signal risk at that same selected time. A phase-comparison theorem controls the actual shared-seed execution under simultaneous changes in the marginals and risk coefficients. A rare repair step then makes the confidence cost additive. Together with matching lower bounds, this removes the remaining logarithmic overhead and parameter restrictions in the general countable-domain sample-complexity problem. This extended version also retains the earlier explicit constructions and their proofs, including proper learning for VC-one classes, the full finite-atom class, a faster realizable bound, and counterexamples that separate restrictions of particular algorithms from restrictions of the learning problem.

Sun 18 OctMachine Learning
The gist
This paper solves a problem about training two separate prediction models so that they give the same answer on any question with high probability. The authors find the best possible number of examples needed to ensure this stable agreement when learning on binary data with some errors allowed. Their method combines multiple trained predictors and carefully picks the final one to guarantee stability even on rare cases. They also prove that their sample size is as small as possible for these conditions. The work extends previous results by covering more cases and removing earlier limitations.
Open → 2610.25062v1

RouteWeaver improves accuracy by smartly mixing language model uses

RouteWeaver: Weaving Mode Selection and Execution into Unified LLM Routing

Abstract: LLM routing dynamically selects and coordinates heterogeneous language models across diverse tasks. However, existing approaches are largely built around a predefined execution paradigm, such as single-round, multi-round, or agentic routing, which fixes how model calls are organized and limits adaptation to different query needs. We propose RouteWeaver, a unified routing framework that integrates these routing modes within a single LLM policy, jointly learning which mode to use and how to select models within that mode. To jointly optimize mode selection and within-mode execution, we develop COMET-GRPO (COordinated Mode-Execution Training), which decouples the trajectory-level advantage into separate signals for mode selection and within-mode execution, enabling more targeted credit assignment to each decision level. We further introduce progressive exploration, which gradually shifts training from externally assigned modes to autonomous selection, so that the router first learns how to execute each mode before deciding when to use it. We evaluate RouteWeaver across mathematics, coding, knowledge, logical reasoning, and factual recall. RouteWeaver achieves an average accuracy of 61.4%, an 11.03% relative improvement over the strongest baseline, and outperforms all compared baselines in each of the five domains. Ablations show that both COMET-GRPO and progressive exploration are important for adaptive routing; without progressive exploration, the routing policy collapses entirely to single-round execution.

Wed 14 OctComputation and Language
The gist
Choosing how to use different language models for various tasks is tricky because there are different ways to combine and run them. The authors created RouteWeaver, a system that learns to pick the best way to use these models depending on the task, all within one approach. They designed a training method that helps the system learn first how to use each way, then when to switch between them. Tested on tasks like math, coding, and reasoning, RouteWeaver performed better than previous methods, showing it can adaptively select the best strategy.
Open → 2610.19705v1

Training stability challenges and solutions for large recommender systems

Understanding and Mitigating Training Instability in Large-Scale Recommender Systems: A Cascade Perspective

Abstract: Training large-scale recommender systems on dynamic industrial platforms, such as Short-Form Video (SFV) services with billions of daily interactions, faces critical stability challenges. Rapid distribution shifts in user data and increasing model complexity frequently trigger a divergence cascade, typically initiating with gradient explosion, propagating to weight explosion, and culminating in loss explosion. This G-W-L cascade severely impedes model convergence and performance. This paper provides a systematic analysis of this G-W-L cascade within an industrial SFV recommender context. We then propose and evaluate a structured mitigation framework where interventions are explicitly mapped to counteract specific stages of the cascade: gradient (G) control, weight/activation (W) stabilization, and loss (L) shaping. Our contribution provides a structured framework for understanding and tackling training divergence, offering practical insights for deploying robust, continuously updated recommenders in large-scale, non-stationary settings. We empirically validate the effectiveness of these strategies on a major industrial SFV recommendation system.

Fri 9 OctInformation RetrievalMachine Learning
The gist
Training big recommendation models that deal with lots of daily user data can run into serious problems where the learning process spirals out of control. The authors studied how this instability happens in a popular video app's recommendation system, identifying a chain reaction that starts with sudden spikes in training signals. They proposed specific fixes targeting each step of this chain to keep training stable. Their experiments showed these methods help maintain reliable and effective recommendations in constantly changing environments.
Open → 2610.14394v1

Tabular foundation models improve dataset representations for machine learning tasks

TabMF: Learning Dataset Representations with Tabular Foundation Models

Abstract: Representations of supervised datasets support higher-level machine-learning tasks such as dataset retrieval and distribution-shift monitoring. However, existing approaches typically rely either on hand-crafted meta-features or on dataset encoders trained specifically for representation learning. We introduce TabMF, a framework that repurposes pretrained tabular foundation models (TFMs) as encoders of supervised datasets. TabMF equips a predictive TFM with an architecture-aware dataset-level readout and adapts the model end-to-end using contrastive post-training on stochastic views of synthetic supervised datasets. We instantiate TabMF on TabICLv2 and TabPFN-2.5 and evaluate the resulting representations across six tasks on unseen real datasets. Simple frozen TFM readouts yield competitive representations, indicating that predictive pretraining already induces substantial dataset-level structure. The two TabMF encoders obtain the strongest aggregate performance among the evaluated learned and classical dataset representations, with particularly strong results in dataset retrieval, compact benchmark construction, and distribution-shift severity assessment.

Fri 9 OctMachine Learning
The gist
Machine learning models often benefit from understanding entire datasets as a whole to improve tasks like finding similar datasets or noticing when data changes. The authors created TabMF, a method that uses existing large pretrained models designed for tables to better represent entire datasets. They showed that adapting these models with special training on many synthetic datasets helps perform better on real data tasks like finding relevant datasets and detecting shifts in data. This method outperforms traditional ways of representing datasets and can help build better machine learning tools.
Open → 2610.13818v1

Semantic views reduce costly ai model calls while ensuring accuracy

Semantic Views: Certified Reuse of LLM Labels Across Semantic Queries

Abstract: Semantic query engines evaluate natural-language filters with a large language model, and every evaluation is a costly oracle call. Optimizers that reduce these calls face a dilemma: cascades that trust a cheap proxy miss their precision and recall targets on many queries, methods with finite-sample guarantees save little, and all of them discard the oracle's labels when the query ends. We present SemViews, a certified semantic filter that orders tuples by signals that cost no oracle calls (the labels that earlier queries left behind as semantic views, a local embedding, and a helper model's score), refines that order with labels it must pay for anyway, and certifies its answer with fresh stratified oracle samples. The answer meets user precision and recall targets with probability at least $1-δ$ for every workload and every catalog, so a stale or misleading view can cost oracle calls but never accuracy. On four workloads replayed against 725,000 recorded oracle labels, SemViews meets both targets on 99.63% of queries and saves 28%-45% of the oracle calls, whereas the only prior method in our study with the same guarantee needs 1.32x-1.71x as many calls. When a question returns in different words, views cut its calls by a further 27%-36%, with both targets met on at least 99.8% of such queries; similarity caches and entailment-based reuse meet them on only 17%-47%.

Thu 8 OctDatabasesArtificial Intelligence
The gist
Answering questions using large language models is expensive because each question requires the model to work hard. The authors introduce SemViews, a system that smartly reuses answers from earlier questions to save these costly model calls without losing accuracy. It orders possible answers based on cheaper signals from previous queries and only confirms uncertain cases with the expensive model. Tests show SemViews saves lots of these costly checks while still being reliable almost all the time.
Open → 2610.12768v1

Model adapts to new tasks without retraining or forgetting old skills

Continual Learning without Continual Training

Abstract: Continual learning requires models to adapt to new domains and new classes while retaining prior knowledge. Many existing methods rely on continued optimization, using regularization, replay, or parameter expansion to prevent new updates from overwriting previously learned knowledge. Instead, we propose replacing continual training with continual inference: a PFN-based model that is meta-trained, and then frozen, adapting to new classes only by extending an in-context evidence set. Our model, Latent Concept PFN, performs in-context Bayesian inference over a latent concept space that captures semantic structure shared across domains and classes. As each new domain or class arrives, exemplars are added to the memory; adaptation reflects updated posterior beliefs over latent concepts rather than gradient updates. No parameters are changed, reducing forgetting. The same method handles both domain and class incremental continual learning without task identity. Concept annotations are only used during meta-training, acting as a soft anchor on the latent space rather than a fixed bottleneck. Unlike fixed-vocabulary concept methods, the model also handles noisy, ambiguous, or incomplete annotations by combining concept labels with raw input evidence to discover distinctions beyond the predefined concept set. Experiments on class and domain incremental learning datasets demonstrate competitive continual learning performance while learning interpretable latent concepts.

Wed 7 OctMachine Learning
The gist
Models that learn new things often forget what they learned before because they keep changing their settings. This paper’s authors propose a method where the model stops changing and instead learns what’s new just by remembering examples it’s seen. Their method uses a special way of thinking about concepts that helps it understand new ideas without losing old ones. This approach works for learning new types of data and new categories without confusion or forgetting.
Open → 2610.10379v1

Transformers learn clustering algorithms with smaller models easily

Leaner Transformers Can Easily Learn to Cluster

Abstract: Transformers have in-context learning capabilities, where some known learning algorithms can be executed in the forward pass through the model. Recent work shows that transformers can exactly perform Lloyd's algorithm for $k$-means clustering with $n$ points in $d$ dimensions with an embedding size $d_{\textsf{emb}} = d+k$ (thus, requiring attention projection matrices of size $(d+k)^2$). In this work, we build upon this result in the following ways: First, we present an equally expressive but smaller transformer that executes Lloyd's algorithm with embedding size $d_{\textsf{emb}} = (d + \lceil \log_2 k \rceil)$. Next, we train these transformers to learn the clustering algorithms given a distribution of clustering tasks, and theoretically characterize and empirically validate the factors affecting the convergence and in-distribution generalization of learning algorithms based on stochastic gradients. Finally, we probe the general clustering abilities of these learned algorithms (in the form of transformers), and try to understand situations where they succeed and fail.

Wed 7 OctMachine Learning
The gist
Clustering is a way to group similar things together automatically. The authors show that a type of AI called transformers can do clustering using fewer resources than before by using smaller internal sizes. They also trained these transformers to perform clustering tasks and studied what helps them learn well and how they generalize to new tasks. Finally, they explored when these AI-based clustering methods work best or might struggle.
Open → 2610.09760v1

Systematic review framework improves machine learning model selection

A Framework for the Systematic Review of ML Assets in AI Registries

Abstract: Background: Modern software systems increasingly rely on Machine Learning (ML) assets (i.e., pre-trained models, datasets, benchmarks) for building, evaluating, and integrating ML-based systems. However, current exploration, selection and reuse practices of ML assets are not supported by systematic retrieval methodologies comparable to those used in traditional evidence synthesis. Consequently, in practice, ML asset selection is often presented as a settled design decision, supported by informal justification rather than a traceable, evidence-based, and updatable selection process. Aims: This paper explores how systematic review methods can support ML asset retrieval. In doing so, we aim to make their selection transparent and reproducible, grounded in explicit evidence, and ultimately better suited to its intended use. Method: We analyze established systematic review practices from scientific literature and adapt their phases (i.e., planning, conducting, and documenting) to Artificial Intelligence (AI) registries, treating ML assets as first-class units of analysis. The resulting framework integrates registry-aware search strategies, cross-registry schema alignment, and dependency-driven ML asset exploration. Results: We conceptualize ML asset retrieval as a systematic and reproducible process rather than an ad hoc activity, and propose a framework for structured ML asset discovery. \textbf{Conclusions:} This work illustrates how systematic review principles can be extended beyond scientific literature to support evidence synthesis over evolving AI registries.

Wed 7 OctMachine Learning
The gist
Choosing the right machine learning models and datasets is often done in an informal way without clear evidence or records. This paper shows how methods used to review scientific papers can help organize and document the search for machine learning assets systematically. The authors create a framework that treats these assets like important data, making it easier to find, compare, and select them with clear reasoning. This approach aims to make machine learning system building more transparent and reliable.
Open → 2610.09551v1

Networked generative models create complex self-learning loops

Stability and Diversity of Networked Self-Consuming Generative Ecosystems

Abstract: The widespread deployment of generative AI has made it increasingly difficult to distinguish synthetic content from real data. Consequently, synthetic data is inevitably incorporated into the training pipelines of future model generations, forming a self-consuming training loop. Prior work has studied the effects of such recursive self-consuming training, but analyses have largely been limited to isolated models, where a model consumes only its own synthetic data, or to simplified interactions between two models. This paper takes a first step toward understanding networked self-consuming generative models, in which multiple models consume synthetic data generated by one another through complex interaction pathways. We introduce a theoretical framework representing models as nodes in a directed, weighted graph, with edge weights governing the flow of synthetic data among models. Using this framework, we analyze the long-term behavior of networked models under retraining dynamics, establishing conditions for convergence and characterizing the resulting fixed points. We further investigate how the system's long-term stability and diversity are shaped by each model's access to real data, cross-model data consumption, and the structure of the interaction graph.

Wed 7 OctMachine LearningComputers and Society
The gist
It is becoming harder to tell computer-made content from real data because AI models often learn from their own creations. The authors study what happens when many AI models learn from each other’s generated content instead of just their own. They use a network approach to map these interactions and find out when the group’s learning stabilizes or stays diverse. This helps understand how sharing synthetic data affects the behavior and reliability of multiple AI systems working together.
Open → 2610.09409v1

Residual entropy provides safer and more informative candidate selection

The Arbitrary-Placement Problem in Entropy-Minimizing Selection, and a Residual-Entropy Formulation

Abstract: Entropy-based selection objectives suffer from a fundamental degeneracy: minimizing Shannon entropy $H(p_A)$ rewards confident selection regardless of whether the selected candidate is informative. We address this limitation with the residual entropy $D = H(p_A) - H(p_β)$, where $p_β$ is induced by candidate trust weights. We prove the exact identity $D = -\mathrm{KL}(p_A\Vert p_β) - Δ$, where $Δ$ measures whether the score-induced distribution and trust profile favor the same candidates. Boundary cases establish basic safety: under uniform trust, $D\leq0$ automatically, so an equal-trust, non-starving state is never penalized, while at any one-hot limit, $D\to0$ regardless of the selected candidate. For the intermediate regime where selection occurs, we prove that $D\leq0$ when candidate ordering by trust agrees pairwise with ordering by informativeness, and derive a tighter certificate based on the leading candidate's margin over its competitors. These results are independent of the candidate-scoring function and apply to both stationary and dynamically changing information. Experiments with a gradient-based mixture-of-experts router confirm that the ordering conditions can hold during real optimization and show that correct ordering improves downstream performance when candidates are non-interchangeable and selections are used directly rather than averaged. Beyond routing, margin-based reweighting matches or outperforms fixed-strength baselines in a class-imbalance task, while informative selection in a production video-prediction system reduces MSE by approximately 20$\%$ and transfers to a related species. Residual entropy, therefore, provides a safety criterion for selection and a usable signal for deciding when that selection is informative.

Mon 5 OctMachine LearningInformation Theory
The gist
Selecting options based on how confident we are can sometimes pick choices that aren't actually helpful. The authors show how a measure called residual entropy can tell when selections really add new information. They prove that this method avoids punishing fair selections and works well when trust and informativeness agree. Experiments with different tasks, like video prediction and handling class imbalance, show this approach can improve results.
Open → 2610.05925v1

Modellakefishing speeds up finding models in huge public model collections

ModelLakeFishing: Efficient Retrieval over Million-Scale Model Lakes

Abstract: Open model lakes may contain millions of reusable models, making it costly to identify suitable models for a new dataset. We present ModelLakeFishing, a model-retrieval framework for queries specifying a target dataset, prediction task, and evaluation metric. It consolidates metadata and historical evaluations into a model-dataset-task evidence graph, learns model and query embeddings with a relation-aware graph encoder, and indexes model embeddings using Hierarchical Navigable Small World (HNSW) search. At query time, HNSW retrieves 1,000 candidates without scoring every model, after which a training-side task prior reranks candidates for the requested metric and returns the top 10. We evaluate on a lake of 3,016,439 models and 247,803 observed model-dataset performance pairs using three root-aware splits that hold test performance edges out of representation learning and retrieval. ModelLakeFishing achieves a mean eligible-query gold@10 of 0.2968, recovering the observed-best model in the top 10 for 29.68% of eligible queries and retaining 93.47% of the gold@10 of an exhaustive baseline using the same scoring and reranking procedure. Given precomputed query embeddings, retrieval and reranking take 0.747 ms median and 1.102 ms at the 95th percentile. These results demonstrate efficient retrieval over million-model lakes from sparse relational evidence.

Sun 4 OctInformation RetrievalDatabases
The gist
Finding the best machine learning model for a new dataset can be really slow when there are millions of models to check. The paper presents ModelLakeFishing, a tool that quickly finds good models by organizing past performance data into a graph and using smart search methods. This way, it narrows down millions of models to a small set and reranks them efficiently. Their tests show that ModelLakeFishing finds top models nearly as well as checking all models but much faster.
Open → 2610.04904v1

Output layer gradients speed up data selection for language model training

LESSER: Post-Training Data Selection with Output-Layer Gradients

Abstract: The choice of post-training data for large language models substantially affects downstream performance. Gradient-based data selection is a popular approach that ranks training data by how well their gradients align with those of a small validation set. However, ranking with full-parameter gradients requires an expensive backward pass on every sample, making computation intractable for large candidate pools. This raises a natural question: can we approximate full-gradient features at a fraction of the cost? Conveniently, we find that output-layer gradients suffice for effective data selection, yet require only the cheaper forward pass. We implement this as LESSER, a drop-in wrapper for selection methods that reduces the feature-extraction FLOP cost by $9.7\times$ for SFT and $3.0\times$ for RL benchmarks, while tracking full-gradient performance on downstream tasks. Empirically, we find that even when output-layer and full gradients rank individual samples differently, they select batches with aligned gradients.

Fri 2 OctMachine Learning
The gist
Choosing the right examples to fine-tune big language models is important but slow because it usually needs a costly calculation for every example. The authors found that looking just at the last layer’s gradients—simpler math done during the model’s usual forward step—works well to pick useful data. They made a tool called LESSER that does this selection much faster while still getting good results. Even if individual examples are ranked differently, the groups of examples chosen end up similarly helpful.
Open → 2610.03702v1

Joint embedding model stability improved by balancing drive and decay forces

Drive vs. Decay: On the Training Dynamics of Joint-Embedding Predictive Architectures

Abstract: Joint-Embedding Predictive Architectures (JEPAs) are prone to representation collapse, typically mitigated through empirical heuristics. We develop an early-training stability theory that unifies these heuristics. Linearising the coupled JEPA gradient flow around the trivial fixed point reveals two competing effects: a driving force ($γ$) and a decay effect ($σ$). Under approximate spectral decoupling, a per-mode stability ratio $μ_i = γ_i / σ_i$ factorises into independent data-side and predictor-side terms and the count of unstable modes tracks the rank of representations that can emerge. The framework predicts a phase boundary, which we confirm empirically across more than 800 Tabular-JEPA configurations. It also unifies predictor scaling, masking ratio, and EMA as distinct mechanisms for shifting $μ$. Guided by this analysis, we introduce ResidualPred, a transformer predictor whose attention is biased toward the identity at initialisation; it improves both effective rank and downstream accuracy on tabular benchmarks and in I-JEPA pretraining on CIFAR-10, CIFAR-100, STL-10, and ImageNet. Our framework connects empirical collapse-avoidance heuristics to an explicit dynamical picture, yielding theory-driven stabilizers. Code is available at https://github.com/jose-melo/drive-vs-decay.

Thu 1 OctMachine Learning
The gist
Training certain machine learning models called Joint-Embedding Predictive Architectures (JEPAs) can fail because the model’s representations collapse and stop learning useful features. The authors explain why this happens by identifying two opposing effects during training: a force that drives learning and another that causes decay. They show mathematically how these effects interact and predict when stable, useful representations will appear. Using this insight, they create an improved model design that leads to better learning and performance on image and tabular data.
Open → 2610.02344v1

Shared model heads in federated regression align via a natural client selection rule

Understanding Head Geometry and Dynamics in Federated Regression through a Natural Solution Selection Rule: An Unconstrained Feature Model Analysis

Abstract: In federated averaging, local objectives can admit multiple optimal heads, making the aggregate depend on which heads clients return. We study this ambiguity in federated multivariate regression with private backbones and a shared linear head, using an unconstrained feature model (UFM) that treats training-sample features as free variables. We introduce a natural selection rule: each client returns the optimal head closest to the broadcast head. We show that global minimization with a vanishing proximal penalty on the head realizes this rule. When the clients' optimal Gram matrices and the initial shared Gram matrix are positive definite, the shared Gram matrix follows a closed recursion and converges to the unique Bures-Wasserstein barycenter of the clients' optimal Gram matrices. Even with this alignment, the limit generally differs from the centralized optimal Gram matrix. We decompose this gap into three positive-semidefinite terms arising from differences in client target means, covariance heterogeneity, and averaging the aligned heads. A correction based on a one-time exchange of target means and covariances recovers the centralized optimal Gram matrix in one round under exact local optimization and the same selection rule. We verify these results numerically in the UFM and test its predictions on five tabular and five image regression datasets using deep networks with feature regularization and long local training. In these experiments, ordinary training approaches the predicted barycenter, while a weak proximal penalty improves endpoint agreement and yields trajectories that closely follow the predicted Gram dynamics. The correction moves the final Gram matrices close to the centralized UFM prediction.

Wed 30 SeptMachine Learning
The gist
When multiple computers learn together without sharing data, they can choose different best ways to predict results. The authors studied how these choices affect the combined model in a simple regression setup. They found a natural way for each computer to pick a prediction method similar to the shared one, helping the group reach a balanced solution. Although this collective solution is different from what a single combined dataset would give, the authors explain why and propose a correction step to fix it. They tested this with simulated and real datasets, confirming their theoretical predictions.
Open → 2609.39464v1

Learning needs fewer samples when training on more domains

How Many Samples Are Enough for Learning Across Domains?

Abstract: Understanding the fundamental mechanisms of learning is essential for designing systems with strong generalization. Recent studies have shown that increasing the number of training domains, or enlarging the distribution shift among them, improves generalization when each domain contains sufficiently many data samples. However, the conditions under which the data samples can be considered sufficient remain unexplored. In this work, we fill this gap by establishing criteria for per-domain sample requirements based on the presented learning bounds. These criteria not only reveal an inverse linear scaling law between the number of training domains and the number of samples required per domain, but also explain the fundamental rationale behind the assumption of data sufficiency, thereby providing theoretical guidance for assessing the adequacy of existing datasets and constructing datasets. This differs from classical learning theory, as the number of samples required is highly dependent on the number of training domains. Additionally, we prove the close relationship between in-domain learning and out-of-domain generalization through the presented generalization bounds, and lastly discuss some key arguments.

Wed 30 SeptMachine Learning
The gist
It can be hard for computers to learn things that work well across different environments or groups called domains. The authors found a rule that shows how many examples computers need to learn well in each domain, depending on how many total domains are used during training. Specifically, they show that if you train on more domains, you need fewer examples from each one. This helps explain when datasets have enough data to teach computers and guides how to build better training collections. They also link learning inside one domain to how well the computer does in new domains.
Open → 2609.39336v1

Dattri-LLM speeds up training data use analysis for large language models

dattri-LLM: A Unified and Efficient Library for Training Data Attribution at LLM Scale

Abstract: Training data attribution (TDA) estimates the contribution of individual training examples to model outputs. Most scalable TDA methods rely on per-example gradients, whose computation and use at LLM scale pose challenges in efficiency, compatibility, and extensibility. We introduce dattri-LLM, a TDA library that makes gradient-based attribution more practical at scale. For efficiency, dattri-LLM uses compact gradient representations and dynamically routes gradient operations based on a cost model. For compatibility, its capture mechanism collects per-example gradients from existing training loops that call backward(), without requiring changes to the loop or its configuration. This includes distributed training with DDP and FSDP and pipelines built with HuggingFace Transformers, TRL, and OLMo. For extensibility, dattri-LLM exposes reusable gradient operations and training-time callbacks for implementing attribution methods and applications. These interfaces support a variety of attribution methods, including gradient similarity, curvature-based influence, and trajectory-based methods, as well as applications that act on gradients during training, such as online data selection. On the same hardware and workload, dattri-LLM achieves 3.2x the throughput of the fastest competing library on average, scales multiple attribution methods to 110B-parameter models across four H200 GPUs, and offers superior attribution fidelity-cost trade-offs across a range of models with different model families and scales.

Wed 30 SeptMachine LearningArtificial Intelligence
The gist
Understanding how each piece of training data influences a large AI model's responses is hard and slow. The authors created dattri-LLM, a tool that collects and uses information from the training process efficiently without needing changes to existing setups. It helps people figure out which training examples matter most, works with very big models, and runs much faster than similar tools. This makes it easier to analyze and improve training data for large models.
Open → 2609.38767v1

Diffusion model fine-tuning makes multi-target domain adaptation efficient

Revisiting Diffusion Fine-Tuning for Unsupervised Domain Adaptation

Abstract: Diffusion-based unsupervised domain adaptation (UDA) improves cross-domain transfer by generating target-specific synthetic data for downstream adaptation. Existing methods are largely designed for single-target adaptation: when a model trained on one labeled source domain must be adapted to multiple unlabeled target domains, they typically require separate diffusion fine-tuning for each source--target pair, causing training, storage, and deployment costs to grow with the number of targets. In this paper, we study multi-target data generation for diffusion-based UDA, where a single source-guided diffusion fine-tuning process is reused to generate target-specific synthetic data for multiple target domains. We propose MUSE (Multi-target UDA-oriented Synthesis with Efficient diffusion fine-tuning), a decoupled adaptation framework that separates source-supervised semantic adaptation from target-specific style adaptation. MUSE uses a shared semantic branch updated by labeled source data and target-private style branches specialized to individual target domains, enabling target-specific generation while avoiding repeated source-guided fine-tuning for each target. Experiments on standard UDA benchmarks show that MUSE achieves a stronger accuracy--efficiency trade-off than repeated per-target diffusion adaptation, reducing diffusion fine-tuning cost while improving average target-domain accuracy. The project page is available at https://xuanqi99.github.io/MUSE/.

Sun 27 SeptComputer Vision and Pattern Recognition
The gist
Sometimes, computer programs need to learn from one set of labeled examples and then work well on many different new types of data without labels. Previously, adapting these programs for each new type took a lot of extra work and time. The paper studies a new approach that fine-tunes the learning process once and then customizes parts of it for each new type, saving time and computer resources. This method produces better results across different new data types while being more efficient.
Open → 2609.33716v1

Hierarchical method improves continual learning for zero-shot graph models

Hierarchical Response Preservation for Continual Adaptation of Zero-Shot Graph-Text Models

Abstract: Pretrained graph-text models align graph representations with textual semantics, enabling recognition of unseen classes and transfer across graph domains. However, as graph data and classes continually arrive, models should learn from new supervision while retaining their zero-shot transfer capabilities and historical task knowledge. Two challenges arise: (i) new classes can overturn historical predictions despite preserved distinctions among historical classes, and (ii) overly strict response preservation can stall learning of new classes. To address these challenges, we propose Hierarchical Response Preservation (HiRP). HiRP represents this competition through a hierarchical response that keeps each historical-class probability and sums new-class probabilities, preserving historical distinctions and aggregate competition while allowing distinctions within the new class group to adapt. It further uses the geometry induced by this response to guide constrained updates, retaining useful adaptation directions while controlling response drift. Across three class-incremental settings, HiRP achieves absolute gains of 1.84-7.95 percentage points in average accuracy over the strongest compared baseline in each setting, while mitigating zero-shot transfer degradation.

Sun 27 SeptMachine Learning
The gist
Graphs and text can be linked by models to recognize new categories without prior examples, but as new classes appear, these models can forget earlier knowledge or fail to learn new classes well. The authors propose a hierarchical way to keep old class information while still learning new classes effectively. This method helps models keep good performance on old tasks and still adapt to new data. Tests show this approach improves accuracy and maintains zero-shot capabilities across various settings.
Open → 2609.33607v1

Quantization harms retrieval results more than classification accuracy shows

The Undetected Damage of Quantization on Retrieval and How to Fix It

Abstract: We show that a quantized model that keeps its classification accuracy still changes $14$ to $46\%$ of its top-1 retrieval results, and that aggregate ranking metrics reveal only part of this damage. We tie this failure to the gap between the two highest scores and use that gap to decide when a quantized answer can be trusted and where additional precision should be spent. We show that the top-1 result is guaranteed to survive quantization only when this gap exceeds twice the largest rounding error. In classification, scores are the logits, and the loss function pushes the correct class away from other classes, encouraging this gap. In retrieval, scores are query-document scores, and nothing separates the top-1 item from the second. This gap can be measured without labels. Before deployment, it predicts which models will break under quantization, and at deployment time it tells, per input, whether the quantized answer still matches the full-precision answer. Most classification inputs have a gap wide enough to trust the quantized answer, but few retrieval queries do. That gap motivates a different fix in each task. In retrieval, spending extra bit-width on the layers whose quantization moves the gap most recovers up to three-quarters of an extra bit's benefit for half its cost. In classification, routing the few low-gap inputs to full precision recovers most of the lost accuracy at a fraction of the cost.

Mon 21 SeptMachine LearningArtificial Intelligence
The gist
When a model is simplified using quantization, its ability to classify things correctly may seem unchanged, but its performance in finding the top search result often changes a lot. The authors explain this by looking at how close the top two scoring items are in retrieval tasks, which isn’t the same in classification tasks. They find that if the score difference is large enough compared to rounding errors, quantization doesn’t change the top choice. This insight allows for smarter use of extra precision where it matters to keep results reliable.
Open → 2609.24322v1

Python library unifies multiple search types with improved ranking

Quanta: A Self-Contained Python Library for Hybrid Retrieval over Quantised Embeddings, Lexical Indexes, and Knowledge Graphs

Abstract: An advanced retrieval-augmented generation pipeline is typically assembled from three or four independently operated systems: an approximate nearest-neighbour index, a full-text search engine, a graph database, and a relational document store. Each contributes its own deployment surface, configuration model, and failure modes, and the integration logic that binds them is written anew in every project. In this work, we present \textsc{Quanta}, an open-source Python library, which unifies dense vector search over 4-bit quantised embeddings, BM25 full-text retrieval, and knowledge-graph traversal behind a single retrieval API. Quanta makes two design commitments, which distinguish it from existing hybrid retrieval stacks. First, signals are combined by \emph{weighted reciprocal rank fusion} rather than by normalising heterogeneous scores onto a shared range, which we argue is ill-posed because such normalisations are query-dependent. Second, the graph is a \emph{candidate expander and not a relevance scorer}: traversal widens the candidate pool, and the newly admitted documents are re-scored by the dense indexes under an identifier allowlist, so structural adjacency determines what is considered while content evidence determines how it ranks.

Wed 16 SeptInformation RetrievalArtificial Intelligence
The gist
Many advanced search systems use separate tools for finding information, making them complicated to set up and combine. The authors created Quanta, a Python library that brings together searches based on word matches, similar meanings, and connections in knowledge graphs into one tool. This approach mixes results by a method that does not require changing scores to fit together, and uses knowledge graphs to expand which documents are considered without affecting their ranking directly. This design aims to make hybrid search pipelines simpler and more consistent.
Open → 2609.18248v1

Transfer learning for adapting to changing data over time

Transfer Learning for Evolving Domains

Abstract: Transfer learning explores how to leverage knowledge from various tasks or domains (sources) to enhance predictive performance in related tasks or domains (targets). Typically, transfer learning research is segmented into several isolated sub-areas (such as domain generalisation, domain adaptation, or multi-domain learning), each making distinct assumptions about target data availability, namely how much data and how many labels are available at training time. However, in many real-world applications, data availability is not fixed but evolves over time, as instances and labels are progressively collected from a new domain. Each of the classical settings then describes only a snapshot of a trajectory that a deployed system must traverse in full. We formalise this trajectory as a transfer learning problem in its own right, Transfer Learning for Evolving Domains (TrED), specified by a data availability process fixed by the environment, a learning protocol that the method is free to choose, and an evaluation criterion that scores the whole trajectory of models rather than a single one. Within this formalism, the classical settings are recovered as regimes that a learner may pass through, rather than as separate problems that TrED concatenates. We then examine the transfer learning literature to identify mechanisms that are promising building blocks for a solution, and find that most methods are tailored to a single regime and that even the strongest existing candidates do not yet optimise the whole trajectory. We argue that TrED is a well-posed and unsolved problem, and an important direction for future research.

Fri 11 SeptMachine Learning
The gist
Many computer programs learn to solve tasks using examples, but often the type and amount of data they get changes over time. The authors point out that most existing learning methods only handle fixed amounts of data at once, not gradually growing data from a new source. They propose a broader way to think about learning that captures how data evolves, calling this Transfer Learning for Evolving Domains (TrED). Their idea helps unify current approaches and highlights that making methods work well throughout changing data availability is still an open challenge.
Open → 2609.13039v1

Llm-driven AutoML with trial correction boosts reliability and performance

SAGE-Loop: Reliable Closed-Loop LLM-Driven AutoML with Trial-and-Correction and Adaptive Ensembling

Abstract: Automated machine learning (AutoML) is reshaping data-driven science and industrial practice, and as large language models are introduced into AutoML, pipeline reliability becomes as important as automation efficiency. However, existing AutoML still struggles to realize instant feedback and adaptive optimization during execution, so once a run drifts into a suboptimal or failed state, it lacks a process-level correction mechanism. The fundamental pathology lies in its one-way pipeline: intermediate failures are typically terminated or bypassed, while fixed paradigms often strengthen model generation but leave ensemble decisions static, weakening both execution reliability and the controlled use of structural diversity. This indicates that LLM-driven AutoML needs a closed-loop ability for trial-correction-improvement together with evidence-based use of model diversity. To this end, we propose SAGE-Loop, a reliable closed-loop, self-adaptive, LLM-driven AutoML framework that performs multi-round generation and validation for trial-and-repair, and adaptively selects ensemble strategies in both supervised and unsupervised tasks, thereby unifying how to generate with how to use models. Across 20 public datasets, SAGE-Loop consistently improves performance and stability on classification, regression, and clustering tasks. Additional results further show its ability to recover from execution failures and maintain robust pipeline behavior.

Fri 11 SeptMachine Learning
The gist
AutoML is a way to automatically build machine learning models, but it often struggles when things go wrong during the process, causing poor results or failures. The authors created SAGE-Loop, a new system that uses large language models to repeatedly generate and check solutions, fix errors, and smartly combine different models to improve reliability. This approach helps AutoML recover from mistakes and perform better on a variety of tasks like classification, regression, and clustering. The system was tested on many datasets and showed consistent improvements in how well and how stably it works.
Open → 2609.12455v1

Synthetic data impact varies by training method in linear regression

Learning with Synthetic Data via SGD in High-Dimensional Linear Regression

Abstract: Synthetic data has become a promising way to scale model training beyond limited human-generated data but it may also induce strong model collapse (Dohmatob et al., 2024), where any fixed fraction of synthetic data prevents model performance from improving under data scaling, leaving a non-vanishing excess risk floor. In this paper, we study how synthetic data affects the generalization of one-pass SGD in high-dimensional linear regression with model shift. We establish finite-sample risk bounds for mixed and two-stage training, separating standard bias and variance from source-mismatch effects, namely fluctuation and persistent drift under mixing and filtered initialization bias under two-stage. These bounds reveal a sharp contrast: mixed training induces strong model collapse, while two-stage training avoids the floor by using synthetic data only in the first stage, showing that collapse is not inevitable under a simple data curriculum. Under a random sketch model, we further obtain scaling laws for both protocols, with tight results for mixed training in the optimization-saturated regime. These laws show that larger models may amplify synthetic-induced degradation under mixing, and quantify how high-quality synthetic pretraining may reduce bias in two-stage training. Finally, we establish an exact finite-sample necessary-and-sufficient condition for two-stage training to strictly outperform real-only training under the same real-data budget and identical real-stage updates. Overall, our results highlight that synthetic data is neither inherently harmful nor beneficial; its effect depends critically on both its quality and the training protocol used to incorporate it.

Wed 9 SeptArtificial IntelligenceMachine Learning
The gist
Synthetic data can help train models when real data is limited, but sometimes it stops models from getting better, causing a performance floor. The authors analyze how synthetic data affects training in a common math problem called linear regression. They find that mixing synthetic data with real data during training causes this performance floor, but using synthetic data only at the start of training avoids it. This means whether synthetic data helps or hurts depends on how and when it's used in training, not just its quality.
Open → 2609.09572v1