Papers for

machine learning system architects

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.

Study limits on memory use for attention with weak key query similarity

Attention under Bounded Key-Query Similarity: Space Complexity and Transformer Anisotropy

Abstract: A growing body of work on KV-cache compression aims to reduce the memory requirements of autoregressive generation. These methods compress the stored context while approximately preserving attention computation, enabling generation with reduced memory consumption. Almost tight theoretical results on the worst case space complexity of attention have recently been obtained, but they are achieved by instances where queries can be perfectly aligned with keys. This directly contradicts the observed anisotropy of the key/query geometry in real transformers. In particular, it has been shown empirically that key/query cosine similarities are small even for most correlated pairs, i.e., near-perfect alignment of queries with keys does not happen in practice. In this paper, we study the space complexity of attention approximation under the assumption that key/query cosine similarities belong to a small interval around zero, i.e., a query cannot align too much with any key. We give a nearly space optimal algorithm and a corresponding space lower bound. Surprisingly, the distribution of key/query cosine similarities in our lower bound exhibits the anisotropy property empirically established and studied in the literature. Additionally, we show that the simple uniform sampling algorithm is nearly optimal for a typical range of parameters, supporting its surprising effectiveness on real datasets.

Mon 26 OctMachine LearningData Structures and Algorithms
The gist
Transformer models use attention mechanisms that match keys and queries, but usually these matches aren't very strong or aligned. This paper studies how much memory is needed to approximate attention when keys and queries can't align closely. The authors provide a near-optimal algorithm and prove a matching lower bound, showing that even with limited alignment, compression of the stored context is possible. They also find that a simple uniform sampling method works well for typical cases, matching practical behavior seen in real transformers.
Open → 2610.35020v1

ReLU networks can be simplified to just two hidden layers

Two $\operatorname{ReLU}$ Layers is All You Need

Abstract: We prove that every $\operatorname{ReLU}$ network can be exactly simulated by a $\operatorname{ReLU}$ network with two hidden layers. We present two proofs: one that is based on fillings in homological algebra and a direct combinatorial proof.

Tue 20 OctComputational ComplexityComputational GeometryMachine Learning
The gist
Neural networks that use the ReLU function usually have many layers to do their job. This paper shows that any ReLU network can be copied exactly using just two hidden layers. The authors give two different proofs, one using ideas from an area called homological algebra and another using direct counting methods. This means complex neural networks might be easier to understand or build.
Open → 2610.28587v1

Dynamic semantic compression boosts large language model speed and memory

Dynamic Semantic Compression for Efficient Latent-Space Inference in Large Language Models

Abstract: Large Language Models (LLMs) primarily perform inference at the token level, resulting in substantial memory overhead and compromised computational efficiency. In this paper, we propose a Dynamic Semantic Extraction and Inference (DSEI) framework, which achieves segment-level inference within the latent space through a two-stage training strategy. First, we construct a Dynamic Semantic Autoencoder (DSAE) via self-supervised learning. DSAE dynamically extracts segment-level semantics and compresses them into compact latent representations via adaptive semantic weighting and gated fusion. Subsequently, we integrate the DSAE into the LLM architecture and train the model to infer over dense latent space. DSEI substantially reduces both input and generation sequences and significantly enhances inference efficiency. Extensive experiments conducted on the Wanjuan dataset demonstrate that DSEI reduces perplexity by 48% compared to static sentence-level latent inference baseline. Furthermore, compared to standard LLMs using token-level inference, DSEI accelerates inference speed by 2.5$\times$ and reduces memory overhead by 90%.

Mon 14 SeptComputation and LanguageArtificial Intelligence
The gist
When computers read and write text, they usually process it word by word, which uses a lot of memory and slows things down. The authors created a new method that groups parts of sentences into meaningful segments and compresses them, so the computer can work with shorter chunks. This method, called DSEI, helps large language models understand and generate text faster and using less memory. Tests showed it made the models almost half as confused about the text and more than twice as fast.
Open → 2609.15338v1

LoopVAE reduces parameters for image tokenization with recurrent depth

LoopVAE: Recurrent Depth Across Scales for Visual Tokenization

Abstract: Hierarchical visual tokenizers typically allocate different processing blocks to different spatial scales. We ask how much of this computation can use the same parameters. LoopVAE reuses a scale- and loop-conditioned core within and across scales, while keeping resolution-changing transitions independent. A four-block core executes 28 block applications per encoder or decoder. On ImageNet-256, the 29M-parameter convolutional model reaches 0.28 rFID and 32.54 dB PSNR under an approximately 30-epoch two-stage training budget, using approximately 65% fewer parameters than the 84M reference VAEs. A non-adversarial Transformer ablation with the same execution graph finds competitive PSNR and SSIM under global sharing, although unshared blocks improve LPIPS. Targeted loop interventions show that completing the trained recurrence improves reconstruction and that even small feature updates can have substantial downstream effects. Truncation also exposes output-range errors, distinguishing useful recurrent computation from reliable early exit. Runtime profiling reveals the execution tradeoff: fewer stored weights require more arithmetic and longer runtime in the tested configurations. With convolutional and Transformer operators and single- or multi-resolution latent interfaces, LoopVAE establishes recurrent depth across scales as a parameter-sharing design axis for visual tokenization.

Thu 10 SeptComputer Vision and Pattern Recognition
The gist
Encoding images efficiently can require a lot of computer memory and calculations. The authors introduce LoopVAE, a system that reuses parts of its processing steps multiple times across different image sizes to cut down on the number of unique parts needed. This reuse leads to fewer parameters while keeping image quality good on a standard dataset. The study also compares different designs and shows that repeating processing steps can have meaningful effects on the final image reconstruction.
Open → 2609.11516v1