Papers for

ai infrastructure 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.

Stochastic gradient methods converge despite rough data and noise

Convergence of Stochastic Gradient Methods under Heavy-Tailed Noise and Hölder Smoothness

Abstract: Classical convergence guarantees for stochastic gradient methods typically assume Lipschitz-smooth objectives and finite-variance gradient noise, both frequently violated in practice. In contrast, we study nonconvex stochastic optimization under the joint relaxation of these assumptions: objectives with $(L,s)$-Hölder continuous gradients, $s\in(0,1]$, and gradient noise satisfying only a bounded $α$-th moment condition for $α\in(1,2]$. We establish three convergence results. Firstly, that standard SGD converges at rate $O(T^{-s/(1+s)})$ whenever $α\ge1+s$, extending the classical nonconvex SGD rate to heavy-tailed noise and Hölder smoothness simultaneously. Secondly, we analyze $δ$-regularized gradient clipping ($δ$-GClip), a provable trainer of wide and deep nets, and establish a stationarity rate of $O(T^{-2s(α-1)/[(1+s)(2α-1)]})$ under the same condition. Thirdly, we analyze standard gradient clipping (G-Clip) and show that it recovers the above rate for $α\ge1+s$ while in the very heavy-tailed regime $α<1+s$, it has a convergence rate $O(T^{-2s(α-1)/[(α-1)+s(2α-1)]})$ --- the first convergence guarantee in this regime for any stochastic gradient based method.

Fri 11 SeptMachine Learning
The gist
Stochastic gradient methods help machines learn by making small, random updates based on data. These methods usually assume smoothness in the problem and limited randomness (noise) in updates. The authors show that even when these assumptions are weakened—such as when the problem is less smooth and noise is heavy-tailed—these methods still reliably find good solutions under new mathematical conditions. They provide specific rates of how fast the methods converge, improving understanding of training deep neural networks with noisy data.
Open 2609.12785v1

Vortex speeds up and cuts energy use in compressed large language models

Vortex: Bridging Extreme Compression and Efficient LLM Inference

Abstract: Extreme compression techniques, including vector quantization (VQ) and input-dependent sparsity, can significantly reduce the memory footprint of large language models (LLMs). However, a key challenge remains in translating such compression into practical efficiency. On conventional systolic-array-based accelerators, VQ incurs high dequantization overhead, while the irregular patterns of input-dependent sparsity are difficult to exploit. In this study, we address these challenges with Vortex, an architecture compatible with systolic-array-based accelerators with minimal hardware overhead, bridging the gap between extreme compression and efficient inference. Vortex adopts a bi-flow execution strategy that efficiently supports vector-quantized models across both prefill and decoding workloads, and we further optimize it through systematic design space exploration. On the algorithm side, we propose codebook-wise contextual sparsity to align with VQ execution. Across end-to-end workloads, Vortex achieves $8.03\times$--$23.7\times$ speedup and $5.68\times$--$12.5\times$ energy reduction over state-of-the-art accelerators.

Thu 10 SeptHardware Architecture
The gist
Large language models need a lot of memory and computing power, which makes them slow and costly to run. The authors introduce Vortex, a new system that helps these slimmed-down models work much faster and use less energy without big hardware changes. They focus on clever ways to handle how the models compress data and how that compressed data is processed. Their tests show big improvements in speed and energy savings compared to current technology.
Open 2609.12208v1

Musec optimizer improves training stability for large language models

Musec: MomentUm SpEctral Clipping for Stable Muon-type Training

Abstract: Muon has emerged as a highly effective optimizer for large language model training, often achieving superior convergence and performance compared with the widely adopted Adam and AdamW optimizers. Nevertheless, Muon is prone to training instability due to its spectral flattening, manifested by loss spikes and unbounded growth of model weights. Existing approaches primarily rely on weight or attention-logit clipping, which require architecture-specific modifications and do not directly address instability across all model components. We propose MomentUm SpEctral Clipping (Musec), which replaces Muon's spectral flattening with spectral clipping: rather than setting all singular values of the momentum matrix to approximately one, Musec clips singular values that exceed a threshold while preserving the underlying spectral structure of the momentum. Our strategy provides an optimizer-level, architecture-agnostic mechanism for stabilizing Muon training. We further develop Soft Musec, an efficient implementation that uses a smooth spectral saturation function approximated by coupled Newton-Schulz iterations. Theoretically, we establish convergence guarantees for Musec in nonconvex nonsmooth stochastic optimization. To the best of our knowledge, this is the first convergence guarantee for Muon-type methods in the nonconvex nonsmooth setting. We provide empirical studies to show that Soft Musec consistently improves training stability over existing Muon variants across a wide range of learning rates and model sizes. Notably, Soft Musec remains stable in settings where existing Muon variants diverge, while matching their performance under well-tuned configurations.

Thu 10 SeptMachine Learning
The gist
Training large language models can be tricky because sometimes the model training becomes unstable and the model's parameters blow up, causing training to fail. The authors propose Musec, a new method that adjusts a specific part of the training process to prevent this instability, making training more reliable without needing special changes to model design. They also develop a smooth version called Soft Musec that works efficiently and maintains good performance. Their results show that Musec helps training stay stable even in tough cases where earlier methods fail.
Open 2609.11655v1

Language models reduce memorization with token importance weighting

Rebalancing Token Importance in Language Models with TF-IDF Weighted Cross-Entropy Loss

Abstract: Large language models are typically trained under uniform token weighting, which allows frequent and low-information tokens to dominate learning and can increase the tendency to memorize surface-level text spans. To address this, we present an information-weighted cross-entropy loss that rescales token-level contributions using TF-IDF statistics, emphasizing semantically informative tokens while down-weighting ubiquitous ones. Experiments on five decoder-only LLMs ranging from 1.1B to 13B parameters show consistent reductions in memorized substring length while preserving perplexity and downstream task performance. Under LoRA fine-tuning, TF-IDF reduces average substring memorization length by 14% across all five models. Under full-weight fine-tuning on TinyLLaMA 1.1B, the reduction reaches 58%. Our approach is architecture-agnostic and can be incorporated into existing training pipelines with less than 3% computational overhead, offering a lightweight and principled way to mitigate memorization without disrupting standard training dynamics.

Thu 10 SeptComputation and LanguageMachine Learning
The gist
Language models usually treat all words equally during training, which causes them to focus too much on common but less meaningful words and memorize exact text snippets. The authors introduce a way to give more importance to rare, meaningful words by using TF-IDF scores inside the training loss. Their method lowers the amount of memorization in several large models without hurting overall performance. This technique works with different model sizes and types, adding only a small extra cost to training.
Open 2609.11029v1

Low-rank evolution strategies improve large language model fine-tuning accuracy

EGGROLL, Unrolled: Understanding and Improving Low-Rank Evolution Strategies at Scale

Abstract: EGGROLL makes evolution strategies (ES) practical for LLMs by replacing dense Gaussian weight perturbations with low-rank Gaussian products, often of rank one. This choice is computationally attractive but geometrically severe: each rank-one perturbation lies in a zero-volume subset of the ambient matrix space, despite having identity covariance. We characterize the mean EGGROLL update field at finite rank and nonzero perturbation radii, then analyze the error of its finite-population estimator. The population field is obtained by applying an explicit resolvent to the gradient of the objective smoothed by the perturbations. We show that the resolvent can introduce a nonconservative component and can reverse the local stability of an optimum. EGGROLL is nevertheless exact on every quadratic objective at every rank and radius. For smooth objectives, its first local finite-rank correction is $O(σ^2/r)$, and nonasymptotic bounds control the resulting field error under smoothness assumptions. Under a local affine model, rank-one perturbations increase the variance of the gradient estimator by only $\frac{2(m+n+1)}{mn+1}$ relative to dense Gaussian ES, or $0.098\%$ for a $4096\times4096$ matrix. We then introduce LOO-ROLL, a leave-one-out estimator that preserves the finite-rank population field while replacing EGGROLL's two antithetic evaluations per direction by one. At equal evaluation cost, LOO-ROLL halves estimator MSE in transformer blocks. At matched wall time across ten post-training settings and models up to 8B parameters, LOO-ROLL improves seven outcomes in individual paired tests, with no significant loss. On the GSM8K test set, accuracy increases from $38.1\%$ to $63.0\%$ at 0.6B and from $65.9\%$ to $80.0\%$ at 8B. Transformer measurements recover the predicted finite-rank variance, while the rank comparisons show no reproducible reward-based advantage for rank eight.

Thu 10 SeptMachine LearningArtificial Intelligence
The gist
Fine-tuning large language models is hard because changing many parameters at once requires a lot of computation. The paper studies EGGROLL, a technique that changes model weights in simpler, low-rank ways that are easier to handle. The authors analyze the math behind these changes and identify potential problems and benefits. They also create LOO-ROLL, an improved estimator that reduces errors and speeds up tuning, showing big accuracy gains on language tasks.
Open 2609.10980v1

Large language models assessed on engineering their own infrastructure

$Φ$-Bench: Can Large Language Models Engineer the Infrastructure That Powers Them?

Abstract: Large language models (LLMs) have demonstrated remarkable capabilities in reasoning and code generation, raising the prospect that they could assist in developing and optimizing the very infrastructure that powers them. However, existing benchmarks mainly focus on isolated kernels, predefined operators, or pre-specified optimization targets, and therefore fail to evaluate the ability of LLMs to perform open-ended, long-horizon LLM infrastructure engineering. To address this gap, we present $Φ$-Bench, a benchmark for systematically evaluating LLMs on engineering the LLM infrastructure stack. Derived from optimization problems studied in frontier research and grounded in real-world code repositories, $Φ$-Bench provides broad coverage of the LLM infrastructure stack and spans tasks of varying complexity, ranging from localized kernel-level function completion to long-horizon implementation and end-to-end system optimization. Extensive experiments on frontier LLMs reveal their current capabilities and limitations in engineering complex LLM infrastructure, offering insights into the challenges that remain on the path toward autonomous optimization of future AI infrastructure.

Wed 9 SeptComputation and Language
The gist
Building and improving the complex systems that run large language models (LLMs) is a big challenge. The authors present Φ-Bench, a new test designed to check how well LLMs can handle tasks like writing code for LLM infrastructure and optimizing entire systems over time. Their experiments reveal what current models can do and where they fall short in managing these complicated jobs. This helps understand how close we are to letting AI improve the tools that support it.
Open 2609.10226v1