Papers for

machine learning engineering 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.

Gpu solver speeds up robot learning and control tasks

CuPIQP: A Batched and Differentiable QP Solver on GPUs for Robot Learning and Control

Abstract: Quadratic programs (QPs) are fundamental building blocks of many robotic tasks such as inverse kinematics, whole-body control, and model predictive control. Extending these methods to large-scale robot learning and control requires solving many QPs concurrently and, for end-to-end learning, differentiating through their solutions. Efficient batched optimization is therefore essential to bringing established model-based methods into GPU-based robotics pipelines. We present \textsc{cuPIQP}, a batched and differentiable QP solver on GPUs based on a proximal interior-point method, with unified support for dense, sparse, and multistage problems. The solver exploits parallelism across independent QPs and their internal structure while preserving per-problem numerical updates and termination decisions. Benchmarks with up to 16384 QPs per batch demonstrate solve-time speedups of up to $18.8\times$ over \textsc{Moreau} and $4.26\times$ over eight-core \textsc{PIQP}. In an end-to-end learning task, \textsc{cuPIQP} accelerates training by $4.6\times$ over \textsc{QPAX} and $7.8\times$ over \textsc{Moreau}. By reducing the computational cost, \textsc{cuPIQP} provides efficient, reusable infrastructure for integrating model-based optimization into large-scale robot learning and control.

Thu 29 OctRobotics
The gist
Solving many small math problems is essential for controlling robots and teaching them new skills, but it can be slow on normal processors. The authors created a new tool called cuPIQP that runs these math problems all at once on graphics cards, which are very fast at handling many tasks simultaneously. This tool not only solves these problems faster but also helps with training robots by making the whole process quicker. It works well for different kinds of problems and saves a lot of time compared to other existing tools.
Open → 2610.41021v1

How retrieved literature shapes ideas generated by large language models

Tracing the Influence of Retrieved Literature on Scientific Ideation in LLMs

Abstract: Large language models (LLMs) are increasingly used to generate research ideas from scientific literature. Existing systems combine literature retrieval with search, generation, and refinement, making it difficult to determine how the retrieval strategy itself shapes the ideas generated. We isolate this contribution by comparing five retrieval strategies and a No Literature baseline under a shared generation protocol, using 45,000 ideas across 15 machine learning topics and ten open-weight models. Relative to no literature basline, all five retrieval strategies reduce diversity among ideas generated from the same set of papers by $5.6\%$--$17.9\%$, while most increase diversity by $10.2\%$--$18.1\%$ when ideas from different sets are pooled. Effects on idea quality and novelty are modest on average but vary across topics. We further apply a JSD-based attribution method to trace the influence of individual input papers on each idea's motivation, core idea, approach, and validation. In $79.3\%$ of ideas, only one or two distinct papers receive the highest attribution scores across these four parts. These leading sources often recur across ideas generated from the same set of papers, and groups with more varied source attribution contain more diverse ideas ($r=0.70$). These findings motivate various sets of literature and the use of attribution to guide the choice of sources for subsequent ideas.

Wed 28 OctComputation and Language
The gist
Generating new research ideas using large language models often involves using retrieved scientific papers. The authors studied how different ways of choosing these papers affect the variety and quality of ideas the models come up with. They found that using retrieved papers generally changes the diversity of ideas compared to using no papers, and that a small number of key papers tend to influence most parts of each idea. This helps understand how the choice of literature impacts the model’s creativity and could guide better strategies for finding inspiring sources.
Open → 2610.39060v1

AI pipeline teams safely reuse evidence to speed releases

Reusing Assurance Evidence in AI Pipelines: Validity Conditions, a Fail-Closed Release Gate, and a Replay of 714 Public Data Version Control Pipelines

Abstract: Rerunning every governance control after every change to an artificial intelligence (AI) pipeline is expensive, so teams reuse earlier results. Reuse is safe only if each control's declared dependencies cover everything that can change its outcome, and only if the release gate checks that reused evidence describes the candidate being released. This article makes both conditions explicit and measures how often the first fails in practice. It defines when a signed evidence record is valid for a candidate and gives sufficient conditions under which change-local re-execution reaches the same release decision as rerunning every control. A reference gate implementing these checks with Ed25519 digital signatures blocks eight of nine manipulation scenarios, against one for a gate that trusts the planner and three for a gate that only verifies signatures; a dependency the policy never declared passes every gate. A replay of 38,083 commits from 714 public Data Version Control (DVC) pipelines measures that failure mode. Reusing stage results according to declared dependencies avoids 83.4% of stage executions, but in 3.3% of commits it reuses a stage whose imported code or referenced configuration changed, and 31% of pipelines are affected. A manual audit confirms the undeclared dependency in 36 of 40 sampled events. Evaluation stages, whose outputs are the evidence, are the most exposed. Adding each stage's static import closure lowers stale reuse to 0.4% while still avoiding 81.6% of executions; sampled shadow re-execution removes far less, and rerunning everything after unexplained changes avoids only 45.3%.

Tue 20 OctComputer Vision and Pattern RecognitionSoftware Engineering
The gist
Running every check in an AI system again after any change can be costly, so teams try to reuse previous checks. The authors studied when reusing these checks is safe and found that missing some dependencies causes problems. They tested a special gate that blocks most bad cases and ran it on many public AI pipeline changes to see how often errors happen. By adding extra checks on imported code, reuse becomes much safer while still saving most of the work.
Open → 2610.27672v1

Reward rate policy gradient improves efficiency in machine learning agents

Reward-rate Policy Gradient for Efficient Machine Learning Engineering Agents

Abstract: Traditional reinforcement learning (RL) techniques focus on maximizing expected cumulative reward, where each action assumes to take a constant unit of time. However, this assumption does not hold for agentic RL tasks such as machine learning engineering (MLE) agents, where actions involve data loading, feature engineering, and model training that take variable durations. Efficiency matters in modern agentic RL where actions are costly. To address this limitation, we adapt from continuous-time RL and Semi-Markov Decision Process (SMDP) formulation and propose Reward-rate Policy Gradient (RPG), where we focus on optimizing the reward rate -- the long-term reward per unit of time. RPG estimates the reward rate from off-policy samples, then charges each action for the time it consumes at that rate. We first conduct theoretical analysis in the bandit setting to establish that RPG approximates the optimal reward rate and empirically demonstrate it outperforms baselines while avoiding enumeration over the policy space, a known issue for an existing method. We then further apply RPG on a small language model (Qwen3.5-4B) with self-improvement loops and empirically show it obtains higher rewards within a fixed time budget than vanilla RL on MLE-Bench and NanoGPT, with a 19.2% and 85.7% margin, respectively. Our method provides a practical solution for optimizing performance under wait time considerations in modern agentic RL tasks, where actions interact with external environments and cost time.

Mon 28 SeptMachine LearningArtificial Intelligence
The gist
Many machine learning agents take different amounts of time to do tasks like loading data or training models, but traditional methods assume every step takes the same time. The authors proposed a new approach that focuses on the reward earned per unit of time, making the agent more efficient. Their method estimates how well actions perform considering the time they take and adjusts the agent’s decisions accordingly. They tested it on small language models and found it performs better within fixed time limits compared to usual methods.
Open → 2609.36393v1

Large language model decoding sped up by smarter expert selection

BASE: Batch-Aware Selection of Experts Using Predicted Removal Error for Efficient MoE Decoding

Abstract: Large language models are increasingly expensive to serve. In large-scale serving systems, autoregressive decoding is often bottlenecked by transferring model weights from accelerator high-bandwidth memory into on-chip SRAM. Mixture-of-experts (MoE) models reduce computation by activating only a small subset of experts per token, but this sparsity does not translate directly to batched decoding. Different requests select different experts; therefore, the combined active set across many concurrent requests can span a substantial fraction of the expert pool and require significantly more expert weights to be transferred. Most expert-reduction techniques make retention decisions independently for each token and therefore do not address this batch-level expansion. More recently, batch-aware methods have attempted to coordinate expert use across concurrent requests and reuse experts already fetched for the batch. Yet their selection criteria are based primarily on router rankings or expert statistics collected during calibration. Consequently, these criteria are not directly tied to the output error caused by dropping an expert, nor do they capture how an expert's contribution changes across tokens at inference time. We instead rank experts according to how much their removal would change the MoE-layer output. To apply this criterion during serving, we train a lightweight linear predictor during calibration that estimates the expert removal cost for each incoming token, and develop custom GPU kernels for cost prediction and expert selection. Across three MoE architectures, BASE improves the quality-efficiency tradeoff without retraining. On Qwen3-30B-A3B, it improves average accuracy by 29.5 points over the strongest baseline at comparable throughput under a tight expert budget. At a higher expert budget, it is 60% faster than dense inference while remaining within 0.4 accuracy points.

Mon 28 SeptMachine Learning
The gist
Large language models can be slow because they use many expert parts, and loading all these parts for multiple requests wastes time. The authors have created a way to predict which experts matter most for each batch of requests to avoid loading unnecessary experts. This method uses a simple predictor to estimate how much leaving out each expert would affect the outcome, improving speed and accuracy without retraining the model. Their approach works better than previous methods and shows big gains on several tested models.
Open → 2609.36222v1