Papers for

natural language processing 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.

Hybrid attention models speed training of diffusion language models

dQwen3.5: Hybrid-Attention Diffusion Language Models

Abstract: Adapting a pretrained autoregressive (AR) model is a cost-efficient route to a diffusion language model (DLM). While nearly all such adaptations start from a full-attention transformer, AR modeling has shifted toward hybrid architectures that interleave attention and RNN layers. This creates an obstacle for adaptation: unlike attention, RNNs are structurally causal and nontrivial to bidirectionalize. Despite this mismatch, we investigate whether such backbones can become effective DLMs by adapting Qwen3.5 at 0.8B, 2B, 4B, and 9B scales, yielding the dQwen3.5 family. We find that hybrid backbones can be efficient starting points for adaptation: against a full-attention control, the hybrid reaches a given training loss in about half the tokens. Across scales, dQwen3.5 resembles full-attention DLMs in any-order decoding behavior and performs strongly under parallel decoding.

Thu 17 SeptComputation and LanguageMachine Learning
The gist
Training advanced language models that can generate text in flexible ways usually starts with a certain type of design called full-attention transformers. The authors looked at a different design that mixes attention with recurrent layers, which are harder to adapt but more efficient. They found that these hybrid models can be successfully turned into diffusion language models and learn faster, using fewer training examples to reach similar performance. This approach works across various model sizes, making it a promising direction to build efficient language models that can generate text in flexible orders.
Open → 2609.20751v1

Language models learn to recall past information only when needed

On-Demand Attention: Language Models Know When to Recall

Abstract: Reasoning and agentic workloads increasingly demand efficient long-context inference. Yet full-attention decoding reads the growing history at every step, regardless of its benefit to the next prediction. We show that a pretrained model's decoding states already contain information predictive of this benefit, before the global read. Building on this finding, we introduce On-Demand Attention (ODA), a local-first decoding method that uses a lightweight recall head to selectively invoke global attention as its predicted benefit changes during generation. ODA trains only the recall head, leaving pretrained weights unchanged and the complete historical KV cache available for future recall. We further implement GPU-side conditional execution in vLLM, translating reduced global reads into practical decoding speedups over full attention at long context lengths. Experiments across Qwen and Gemma models, including hybrid-attention backbones, show that selective recall recovers most of the performance lost under local attention while substantially reducing global reads. These findings support long-context inference in which pretrained models guide their own access to the information they retain.

Thu 17 SeptComputation and Language
The gist
Long language conversations or documents are hard for AI to read efficiently because they look at everything every time. The authors found that language models already have clues inside them that tell when looking at the whole past will help predict the next word. They built a system called On-Demand Attention that uses a small part of the model to decide if it should check the entire history or just a nearby part. This way, the system works faster without losing much accuracy, making AI better at reasoning over long texts.
Open → 2609.20734v1

Probabilistic approach improves representing uncertain temporal relationships

PAA: The Probabilistic Allen Algebra: A Generative and Complete Probabilistic Extension of Allen's Interval Relations

Abstract: Allen's interval algebra is a qualitative calculus for temporal relations, but its thirteen base relations are crisp predicates over exact interval boundaries. This is inadequate for temporal information from language, perception, databases, or uncertain histories, where times, durations, and boundaries are uncertain and expressions such as "just before" or "roughly during" have graded meaning. We develop the probabilistic Allen algebra (PAA): a generative and complete extension in which relation probabilities are derived from distributions over interval boundaries rather than assigned as scores. Time points are Gaussian; intervals have Gaussian midpoints and truncated-Gaussian durations. Every relation is a boundary-ordering predicate in one common probability space: point-point relations reduce to error functions, and point-interval and interval-interval relations to multivariate Gaussian orthant probabilities induced by linear inequalities. Contact relations (meets, starts, finishes, equals) receive positive measure through a tolerance band, and under a single tolerance the thirteen relations form a true partition that recovers crisp Allen as the tolerance vanishes. The construction derives Allen's taxonomy rather than positing it: coarse predicates such as precedence, overlap, and containment are unions of leaves whose probabilities are leaf sums, and this hierarchy is preserved as intervals collapse to points and thirteen relations reduce to five and then three. Each relation further decomposes into correlation-aware temporal primitives in the spirit of CIDOC CRM. The algebra is scale-invariant and separates graded expressions such as "shortly before" from contact relations. All results are Monte-Carlo validated and shipped as an open, tested Python package.

Thu 17 SeptArtificial IntelligenceComputation and Language
The gist
Allen's interval algebra traditionally deals with time intervals using exact start and end points, but real-world timing is often uncertain and fuzzy. The authors develop a new probabilistic version that models time points and durations as statistical distributions, allowing for graded and uncertain expressions like "just before" or "roughly during." Their approach mathematically derives all the classic interval relations using probabilities instead of crisp rules, maintaining a consistent hierarchy and allowing more realistic temporal reasoning. They also provide open-source Python code to make this method accessible.
Open → 2609.20634v1

Limits on understanding confidence in token-based diffusion models

Limits of Confidence in Diffusion

Abstract: Discrete diffusion, including remasking and uniform-state samplers, generate a sequence by writing multiple token positions per step, drawing each from a per-position distribution and choosing which positions to write from those same distributions. For domains of general interest (pixels, phonemes, or words) there are inherent dependencies between tokens. We show that a step matches the training distribution only when the positions it writes are conditionally independent given the tokens already fixed, that no product of per-position distributions can match a dependent group, and that per-position distributions do not determine whether a group is dependent: two joint distributions can have identical per-position marginals while differing in which combinations of values occur. On ScanAndAdd, a synthetic task whose joint distribution is available in closed form, we verify that every group of two or more undetermined positions a confidence ranking writes is dependent, and measure the generated distribution to be $29\times$ the sampling-noise floor total variation while per-sample metrics are $1.0$.

Thu 17 SeptArtificial Intelligence
The gist
This paper looks at how discrete diffusion models produce sequences by updating multiple parts at once, each chosen from probabilities at each position. The authors found that if the parts being updated depend on each other, the model’s step won’t match the training data distribution well. They show mathematically and with a test example that token dependencies matter and that just knowing single-token probabilities isn’t enough to capture these dependencies. This means that the model’s confidence in certain tokens can be overestimated when dependencies exist.
Open → 2609.20581v1

Relational attention improves language models with less data

Relational Attention for Data-Efficient Language Modeling

Abstract: We present Relational BabyLM, a system submission to the BabyLM 2026 challenge that combines two cognitively motivated inductive biases in a single decoder-only Transformer. Architecturally, we replace standard self-attention with a Dual Attention Transformer (DAT), which separates the routing of object-level ("sensory") lexical features from structural/relational information (Altabaa and Lafferty, 2025; Altabaa et al., 2024; Webb et al., 2024; Kerg et al., 2022; Webb et al., 2021). Relational attention (RA) disentangled from self-attention greatly increases data efficiency and out-of-training-sample generalization on purely relational tasks, but language modeling requires object-level and relational information to be integrated as well as disentangled, and RA-based LMs have remained largely unexplored. BabyLM's data-constrained training and comprehensive evaluation is an ideal testing ground for whether that data efficiency transfers. As a training intervention, we add a Next-Latent Prediction (NextLat; Teoh et al. 2026) objective that encourages hidden states to compress history incrementally into a dense belief state. Architecture is the dominant factor for structural linguistic generalization; the objective is secondary but still significant. DAT's three relational attention types (full RA vs. the simpler RCA and DisRCA variants) are largely interchangeable at 10M words; full RA pulls ahead at 100M. We also introduce a novel symbol-retrieval mechanism (RoPE-based, as opposed to learned, relative symbols) that matches learned symbol libraries while adding no parameters. On the strict (100M-word) track, our best model ranks 6th of 55 overall and 3rd of 55 on the leaderboard's NLP-task subset at the time of writing; our two strongest models outperform the GPT-2 baseline on most benchmarks, with one attaining the highest EWoK score among strict-track entries.

Thu 17 SeptComputation and LanguageMachine Learning
The gist
Language models usually learn from a lot of text, but this work shows a way to make them learn better with less data. The researchers combined two types of attention in a Transformer model to better separate word meanings from sentence structure. They also added a training step to help the model remember and predict what's coming next more efficiently. Their method ranked well among many entries using a limited amount of training data, especially on language tasks requiring understanding relationships.
Open → 2609.20530v1

LLM reproducibility does not guarantee accurate measurement of AI concerns

Reproducibility is not construct validity: LLM measurement of institutionally situated communication

Abstract: High annotation reproducibility does not necessarily imply that an LLM-inferred measure captures the construct it is intended to measure. We test this distinction using a dataset from the European Commission's AI Act consultation, linking structured survey responses to free-text consultation submissions from the same stakeholders. LLM annotations of consultation submissions are highly reproducible (intraclass correlations > 0.99), yet show limited convergence with survey-reported measures of the nominal construct they were intended to approximate. Divergence between survey-and LLM-inferred text-based measures varies systematically across stakeholder groups: business associations express greater concern about AI risks in text-based consultations than in survey responses ({g} = +1.0), whereas public authorities and several nonbusiness groups show smaller or negative divergences. Divergences between scores suggest positive spatial autocorrelation across European countries (Moran's I = 0.347, p = 0.036), indicating that stakeholders from neighboring countries tend toward more similar text-based stances towards AI safety concerns. Despite divergence, survey-reported concerns remain strongly associated with support for explainability across all divergence levels. These results demonstrate that LLM annotation reproducibility can coexist with poor construct correspondence and motivate validation procedures that distinguish reproducibility, construct validity, and communication context variation when LLMs are used as measurement instruments.

Thu 17 SeptArtificial IntelligenceComputation and LanguageComputers and Society
The gist
High consistency in how large language models (LLMs) label text does not mean those labels truly reflect the real concerns people express. The authors studied comments and surveys about AI safety from European stakeholders and found that while LLMs agree very closely with themselves, their results don’t always match what people say in surveys. Different groups, like businesses versus public authorities, show varying differences between their text and survey answers. Also, people in nearby countries tend to have similar text-based opinions about AI risks. This shows that being consistent is not the same as measuring the right thing.
Open → 2609.19866v1

Higher-order pruning enables better compression of large language models

Higher-order pruning of experts in mixture-of-experts language models

Abstract: Mixture-of-Experts (MoE) language models suffer from large parameter counts, which create a significant memory bottleneck. Expert pruning is the most direct approach for reducing this parameter count, yet existing methods make pruning decisions for each expert independently, and assume experts' contributions are purely additive. In reality, expert usage in MoEs is inherently cooperative. We derive HOPE (Higher-Order Pruning of Experts), a second-order pruning objective which provably minimizes an upper bound on the error resulting from pruning. We show that REAP (a state-of-the-art first-order pruning method) is a special case of HOPE where interaction terms are ignored. Across three frontier MoE models (up to 122B parameters), two distinct calibration sets, and multiple benchmarks (including math, instruction following, coding, and an agentic suite), we demonstrate that HOPE produces better pruning decisions than existing methods, and its advantage is most pronounced at high pruning rates and on challenging agentic workloads. At 50% pruning, HOPE outperforms all baselines and achieves an average rank of 1.58 out of 5 methods (versus 2.42 for the next-best method, REAP), with gains of up to +6.1% on agentic coding. Over all conditions, HOPE again achieves the best average rank and surpasses every other method in the majority of head-to-head comparisons. By preserving cooperative expert structure that first-order methods ignore, HOPE enables aggressive compression with minimal degradation, particularly on complex tasks where diverse expert combinations are invoked over long sequences.

Wed 16 SeptMachine LearningArtificial Intelligence
The gist
Large language models with many parts called experts sometimes use too much memory. The authors show that by considering how these experts work together, rather than separately, they can pick which experts to remove with less harm to the model’s ability. Their new method, called HOPE, works better especially when cutting the model size in half and on complex tasks like coding and following instructions. This lets big models run more efficiently without losing much performance.
Open → 2609.18916v1

Quantum transformer models generate synthetic languages with grammar rules

Variational Quantum Transformer Architecture for Synthetic Language Generation

Abstract: We propose a compact NISQ-compatible quantum transformer architecture for synthetic QNLP sequence modelling. The model preserves the autoregressive next-token interface of a classical transformer, but replaces attention and feed-forward sublayers with variational quantum encoder blocks, connector circuits, decoder blocks and a direct two-qubit measurement readout. Token contexts are angle-encoded into small quantum registers, processed by parallel variational heads and encoder integration circuits and conditioned through decoder ancillae to produce a distribution over a four-token vocabulary. We evaluate several architecture variants on deterministic and lexicographic grammar-generation tasks against a compact classical transformer baseline. The quantum models are trainable end-to-end and learn nontrivial grammar structure, including perfect deterministic generation in individual runs and high lexicographic validity in the strongest variant. The classical baseline remains more accurate and stable and the quantum models are sensitive to initialization. The contribution is therefore not a claim of quantum advantage, but a concrete architecture and evaluation of transformer-inspired QNLP sequence modelling under near-term quantum constraints.

Wed 16 SeptComputation and LanguageMachine Learning
The gist
This paper studies how quantum computers can be used to create language models similar to those used for understanding and generating text. The authors designed a small quantum version of the popular transformer model, replacing some parts with quantum circuits that process information differently. Their quantum models learned to produce simple languages with correct grammar, although classical models still performed better. This work shows a practical way to build quantum language models that run on near-term quantum devices, without claiming they outperform classical methods yet.
Open → 2609.18565v1

Spectral method guarantees approximate label recovery on noisy signed graphs

Provable Guarantees for Spectral Structured Prediction

Abstract: Structured prediction is the simultaneous prediction of multiple labels, and is widely used in various fields, such as natural language processing and computer vision. In this paper, we study binary node label recovery on signed graphs with edge-flip noise, a model introduced by (Globerson et al., 2015), via a simple spectral method that decodes node labels from the signs of the principal eigenvector of the noisy signed adjacency matrix. We develop graph structure-agnostic theoretical guarantees for approximate inference of node labels as well as guarantees for maximum angle deviation with respect to the ground truth node labels. By leveraging tools from matrix concentration theory and eigenvector perturbation analysis, we derive new concentration inequalities that explicitly quantify the effect of the spectral gap of the adjacency matrix, number of nodes, degree distribution, and noise level. As a corollary, we relate our general results to the Cheeger constant and provide results for different classes of graphs. We perform several synthetic experiments to validate our theory. To the best of our knowledge, we are the first to provide theoretical guarantees for the spectral-based approach. As a byproduct of our analysis, we derive technical results that might be of independent interest and useful for other machine learning problems.

Wed 16 SeptMachine Learning
The gist
Structured prediction is about guessing many related labels at once, like figuring out multiple parts of a picture or sentence. This paper looks at a problem where labels are nodes in a network with positive and negative links that can be noisy. The authors show that looking at the main eigenvector (a mathematical summary) of this noisy network can still approximately recover the true labels, with guarantees on how close this recovery is. Their work provides new math tools that explain how well this works depending on network size, noise, and structure.
Open → 2609.18527v1

Rotating sparse connections match full attention with fewer links

Reaching Every Position Without Searching: Rotating Sparse Wiring on the Hypercube as a Substitute for Attention

Abstract: Attention pays, at every layer and for every input, the cost of searching for whom to connect. We ask how far one can get with wiring that is fixed, sparse, and simply rotated from layer to layer. Treating the $n$ positions of a sequence as the vertices of a $\log_2 n$-dimensional hypercube and connecting each position, at layer $\ell$, to its neighbour along dimension $\ell \bmod \log_2 n$, information from every position reaches every other in $\log_2 n$ layers with $2n$ links per layer instead of $n^2$. On a synthetic task that is unsolvable unless all positions are reached, this rotation matches all-to-all wiring at $1/32$ of the links, while the same sparse pattern held fixed across layers fails; what matters is that every dimension is touched, not the order. On character-level language modelling of a public corpus (the first $12$M characters of enwik8), a hybrid that keeps two attention layers among sixteen sparse ones reaches $0.06$ bits-per-character lower held-out loss than a fully attentive model of the same width at the same step budget (three seeds each, no overlap), with $1/7$ of the links, $42\%$ fewer parameters, and $2.4\times$ less wall-clock time; the purely rotated schedule is level with the hybrid. The same ordering holds on a second corpus of mixed Japanese, English and code, where the gap widens to $0.16$. The usable learning-rate window is four to eight times wider than attention's on both. We also report what did not work - learned coordinates, and a "dynamics" variant whose apparent gains turned out to be an artefact of a saturated kernel - and the measurement discipline (frozen corpus, full-coverage evaluation, seed spread as the bar for ranking) that we found necessary to say anything at all at this scale.

Wed 16 SeptMachine Learning
The gist
Attention mechanisms in AI usually check every possible connection, which takes a lot of work. The authors show that by thinking of positions in a sequence as points on a cube and rotating which neighbors are connected in each layer, information can flow efficiently without searching. Their method uses far fewer links but still lets information reach every position quickly. Tests on language data show this approach can be as good as or better than standard attention while using less computation and being faster.
Open → 2609.18145v1

Tactics improves machine translation tests by smartly picking diverse text

TACTICS: Taxonomy-Aware Intelligent Corpus Sampling for Machine Translation

Abstract: Large-scale machine-translation (MT) systems are typically evaluated on random samples from a corpus whose distributional composition is an artifact of how it was assembled. Such a sample inherits the phenomena the collection happens to contain rather than the full space a system must handle, spanning rule-governed conventions (terminology, punctuation, currency formatting) and context-dependent phenomena (tone, honorifics, document-level coherence), and thus provides no coverage guarantee for assessing robustness. We propose TACTICS (Taxonomy-Aware Coverage-opTimized Intelligent Corpus Sampling), which recasts coverage as an explicit objective. TACTICS induces a hierarchical taxonomy from a locale style guide, classifies segments against it, and selects a fixed-budget subset jointly optimizing coverage of rare categories, document-level coherence, and distributional fidelity to the full corpus. Applied to MT evaluation across four translation directions, TACTICS improves coverage of rare categories over lexical and embedding-based selection. By targeting the phenomena that separate systems, TACTICS makes a fixed evaluation budget go further, recovering the true system ranking from far fewer segments than random sampling wherever a real quality gap exists and never signaling a difference where none exists.

Wed 16 SeptComputation and LanguageMachine Learning
The gist
Machine translation systems are usually checked by testing on random samples of text, which may miss important types of language use. The authors created TACTICS, a method that organizes text samples based on detailed language categories from style guides, then selects examples that cover rare and important language features. This approach helps test machine translation more fairly and efficiently, giving clearer results with fewer examples. It also avoids false signals when systems do not actually differ in quality.
Open → 2609.17956v1

Multi-judge system detects errors in vision-language text across languages

Vroom-Vroom at SHROOM-Visions: A Multi-Judge Committee for Detecting Hallucinated Spans in Vision-Language Outputs

Abstract: This paper describes our submission to the SHROOM-Visions shared task on detecting and classifying hallucinated character spans in vision-language model outputs across four languages. We employ several fine-tuned vision-language models as independent annotators and combine their span predictions through character-level majority voting, and additionally explore activation probes. The approach ranks first in three of four languages and places on the podium in every language and metric. Our analysis indicates that disagreement among diverse models tracks disagreement among human annotators.

Tue 15 SeptComputation and LanguageArtificial Intelligence
The gist
Sometimes computers that describe images make mistakes by adding details that aren’t really there, called hallucinations. The authors created a system where several different AI models each point out suspicious parts in the descriptions, then combine their votes to decide which parts are likely errors. Their method worked very well in several languages, even beating other submissions in a shared challenge. They also found that when these models disagreed, humans often disagreed too.
Open → 2609.17327v1

Transformer language model improves generalization with recurrent memory

Persistent Recurrent Memory Between Transformer Layers - Improves Language Model Generalization

Abstract: We introduce a simple architectural modification to decoder-only transformers: a persistent recurrent state that observes hidden representations via cross-attention, updates itself through a GRU, and modulates subsequent processing via gated addition. Inserted between the lower and upper halves of a 6-layer transformer, this module adds only 3.7\% additional parameters while reducing evaluation loss from $2.438 \pm 0.004$ to $1.743 \pm 0.018$, corresponding to a 28.5\% reduction on held-out language modeling data. The improvement is statistically significant across 5 random seeds ($p < 0.01$) and corresponds to reduced overfitting (generalization gap 0.12 vs 0.26). Through controlled ablations, we demonstrate that the improvement stems entirely from the persistent memory topology, not from auxiliary self-prediction objectives. A model with identical topology but no auxiliary loss performs equivalently, while a random auxiliary loss provides no benefit. Representation probing reveals that the persistent state encodes narrative position (52\% vs 33\% chance level)---information that standard attention maintains less efficiently. Our results suggest that bridging transformer layers with a lightweight recurrent memory is a simple, effective approach to improving generalization in small-scale language models.

Tue 15 SeptComputation and Language
The gist
Language models sometimes struggle to learn well from small amounts of data without overfitting. The authors added a small extra memory component between layers of a transformer model that keeps track of information over time. This change made the model better at predicting text it hadn’t seen before, reducing errors significantly. They showed this improvement came from the new memory setup itself, not from any extra tasks or tricks. The memory also seemed to help the model understand story position, which normal transformers handle less effectively.
Open → 2609.17251v1

Multi-hop question answering errors split between retrieval and extraction

Diagnosing the Fact-Grounding Gap in Multi-Hop Question Answering

Abstract: Multi-hop question answering requires combining information from multiple documents to answer complex questions. These systems have grown increasingly capable, yet when they fail, the error is typically attributed to not finding the right documents. Whether this holds at the level of individual reasoning steps remains largely unexamined. We investigate this across three standard multi-hop QA benchmarks and find that failures decompose into two distinct modes: retrieval failures, where the needed passage was not retrieved, and extraction failures, where the passage was retrieved but the needed fact could not be extracted - a phenomenon we term the fact-grounding gap. Extraction failures account for nearly half of all per-hop deficiencies and are invisible to standard retrieval metrics. They remain unresolved by every retrieval intervention we test, establishing a ceiling for retrieval-only improvements. The gap's severity varies across benchmarks and question types, but extraction failures appear on every dataset we measure. Our findings reveal that retrieval failures and extraction failures are fundamentally different bottlenecks requiring different solutions - a distinction absent from current evaluation practice.

Tue 15 SeptComputation and LanguageArtificial IntelligenceInformation Retrieval
The gist
Answering complex questions often needs combining facts from multiple documents. This paper finds that mistakes happen not only when the right documents are not found but also when the needed information is in the documents but can't be identified. The authors call this second type the fact-grounding gap. They show that this gap accounts for nearly half of all mistakes and isn’t noticed by current tests that only check document retrieval. Their work suggests different solutions are needed for each problem.
Open → 2609.17043v1

Quantum augmented transformer improves long step reasoning accuracy

QART: A Quantum-Classical Hybrid Architecture for Long-Horizon Reasoning -- Exploring a Conditional Path toward Quantum Scaling

Abstract: Long-horizon reasoning is vulnerable to early errors that compromise later decisions. We present QART, the Quantum-Augmented Reasoning Transformer, a quantum--classical hybrid architecture combining a backbone language model with quantum encoding, CIM-based QUBO optimization, and quantum decoding. Semantic information can come from hidden representations or model-generated text; detailed encoding and optimization procedures remain proprietary. Under explicit assumptions, we establish a conditional asymptotic reliability separation from single-trajectory autoregressive LLMs. For a common task family with aligned optimality and acceptance criteria, autoregressive acceptance probability tends to zero when cumulative conditional risk of irreversible errors diverges. QART's task-optimal-path recovery probability remains bounded away from zero if conditional probabilities for optimal-path coverage and semantic fidelity, spectral certification, dynamical reachability, and faithful readout remain uniformly positive under a specified resource schedule. The architecture alone does not imply these bounds. Paired measurements on six long-horizon benchmarks using DeepSeek V4 Flash, GLM-5.3, and GPT-5.5 xhigh in a Codex agent environment favor QART in 14 of 15 backbone--benchmark pairs. Relative gains reach 84.0% on SciCode, 47.6% on $τ^3$-Bench, and 44.4% on Terminal-Bench 4.0; the DeepSeek V4 Flash configuration regresses by 7.8% on DeepSWE. These results do not directly validate the asymptotic separation. Potential quantum scaling laws are formulated as conditional hypotheses. A quantum-advantage interpretation requires a demonstrated CIM quantum advantage over strong classical solvers and its transfer to end-to-end reasoning after all system overheads.

Tue 15 SeptArtificial Intelligence
The gist
Long-step reasoning tasks often fail because early mistakes cause bigger problems later on. The authors introduce QART, a hybrid system that combines a traditional language model with quantum computing elements to reduce such cascading errors. Their approach shows better success rates on multiple challenging benchmarks compared to standard models. However, the quantum advantage claimed depends on unproven assumptions and further demonstration of quantum hardware benefits.
Open → 2609.16887v1

Vision language model components differ in gender bias sensitivity

Mechanism-Level Evaluation for Vision-Language Models: Controlled Activation-Replacement Diagnosis of Gender Bias

Abstract: Behavioral benchmarking reveals \emph{what} biases exist in vision-language models but not \emph{which internal components} are most sensitive to targeted intervention, precluding principled intervention. We argue for mechanism-level evaluation as a necessary complement, demonstrating causal mediation analysis as a diagnostic instrument for gender bias. We decompose gender-cue effects into controlled indirect effects attributable to specific-layer activations and direct effects through all other pathways, producing layer-by-layer mechanistic signatures. Across six models spanning three architectural families (LLaVA-1.5, LLaVA-NeXT, InstructBLIP at 7B/13B) and two 8B-scale architectures, three findings emerge: language-layer activations exhibit the greatest output sensitivity under controlled intervention, with the direct component often carrying the opposite sign; architectural choices redistribute layer-wise sensitivity to activation replacement; and counterfactual scores diverge from surface-level scores, exposing implicit associations. Systematic ablation validates internal consistency. An intervention experiment finds that the average indirect effect (AIE) and downstream intervention effectiveness are only weakly correlated (Pearson $r = 0.33$), and the layer with the second-largest AIE produces near-zero bias change---indicating that mechanistic diagnosis captures activation-replacement sensitivity but does not, by itself, identify optimal intervention targets. These results show mechanism-level evaluation captures architecture-specific sensitivity patterns that behavioral benchmarks cannot; pairing both should become standard NLP practice. Code: https://github.com/zhaozhipeng1997/CARD-GenderBias.

Tue 15 SeptMultimedia
The gist
Vision-language AI models can show gender bias, but it’s not clear which parts of the model cause that bias. The authors developed a way to check which internal layers of the model react most when gender-related changes are made. They found that language-processing parts of the models are often most sensitive to bias. This method helps reveal hidden biases inside the model’s structure that simpler tests might miss, but it does not by itself tell developers the best way to fix those biases.
Open → 2609.16651v1

Gating controls memorization and learning in state space models

On the Importance of Gating: Memorization vs. In-Context Learning in State Space Models

Abstract: State Space Models (SSMs) have emerged as a compelling alternative to Transformers, enabling sequence modeling with constant memory and linear compute. Although SSMs exhibit reasonable performance and favorable computational characteristics, they continue to lag behind Transformers on tasks that require in-context learning and precise retrieval, slowing their adoption for large-scale language modeling. In this work, we demonstrate that both the success and failure of SSMs in these domains can be explained by studying the role of the gating mechanism, a prevalent component in modern recurrent networks. Specifically, we show through theory and experiments that this gating mechanism causes SSMs to first learn an in-weights "memorization" solution, while delaying, or even preventing, convergence to a correct in-context learning solution. Importantly, this happens even in cases where there are no fundamental limitations due to the architecture or its memory capacity. On the other hand, we find that gating is often beneficial for improving generalization to long sequence lengths. Our results illuminate the crucial role of the gating mechanism in shaping both the training dynamics and generalization of SSMs, and provide a basis for understanding and improving linear-time models.

Tue 15 SeptMachine LearningArtificial Intelligence
The gist
State Space Models (SSMs) are an efficient way to process sequences but struggle with learning from context and recalling specific information compared to Transformers. The authors found that a component called gating makes these models focus first on memorizing information inside their parameters and delays or blocks their ability to learn from the sequence in real time. Interestingly, gating also helps these models work better when dealing with longer sequences. This research helps explain how gating shapes learning and could guide improvements in fast, memory-efficient sequence models.
Open → 2609.16540v1

SL n space improves graph and order data representation accuracy

$\mathbb{SL}(n)$ Representation Learning: An Intrinsic Mixed-Curvature Space with Higher Curvature Capacities and Deeper Order-Aware Composition

Abstract: Mixed-curvature representation learning seeks to capture rich geometric structures that cannot be adequately modeled by a single curvature regime. Existing approaches largely rely on product manifolds, which require manually specifying how different curvature spaces are combined and separate their curvature contributions across factors. We introduce the $\mathbb{SL}(n)$ space, a representation geometry defined by the simple $\det(A)=1$ constraint and a left invariant Schatten-$p$ Finsler structure. Despite this minimal construction, $\mathbb{SL}(n)$ exhibits pointwise negative, zero, and positive flag curvature around a common flagpole, while its mixed-curvature and curvature-coupling capacities are asymptotically maximal relative to the intrinsic geometric upper bound. Beyond geometry, its noncommutative group structure provides inherent order sensitivity, and its non-nilpotent Lie algebra admits nonzero nested Lie brackets at arbitrary depth, enabling deep order-aware composition. Empirically, $\mathbb{SL}(n)$ consistently outperforms a broad range of representation manifold baselines across graph benchmarks at different scales. It reduces average distortion over the strongest baselines by $44.3\%$ on KEGG and $40.5\%$ on HumanCyc, and improves Hits@20 by $42.8\%$ on OGBL-PPA. Experiments on Flickr30k-Order further support its ability to capture higher order dependencies from ordered composition. Together, these results show how a seemingly simple structural constraint can yield unexpectedly rich geometry, capacity, and composition within a unified representation space.

Mon 14 SeptMachine Learning
The gist
Some data has complex shapes and relationships that are hard to capture using simple geometry. The authors introduce a new mathematical space, called SL(n), which naturally combines different types of geometric curvature in one setting. This space also keeps track of the order in data, which helps understand sequences and compositions better. When tested on various graph and ordered data tasks, SL(n) performed better than existing methods, reducing errors and capturing deeper patterns.
Open → 2609.15083v1

Deeper and bigger language models improve performance with less training data

Depth and Scale in the Sub-150M Regime: JugnuLM-53M vs JugnuLM-110M

Abstract: We scale our conventional sub-150M pretraining recipe from 53.5M to 109.7M parameters, holding the method fixed (Qwen3-style decoder with grouped-query attention, RoPE, SwiGLU, RMSNorm, QK-Norm, and a z-loss; FineWeb-Edu data) and changing only the geometry to a deep-and-thin 23-layer x 576-hidden design. The larger model improves across the board -- BLiMP 78.1 -> 81.3, ARC-Easy 51.4 -> 52.5, WikiText-2 byte-perplexity 2.04 -> 1.95 -- and its 81.3% BLiMP essentially matches GPT-X2-125M (81.28) at about 12% fewer parameters. Notably the 110M model achieves this on fewer training tokens (about 8B vs 12B), so the gain is attributable to capacity and depth, not more data. Both models are deliberately conventional; this report is a clean scaling control and the baseline rung (R0) of an ablation study of what further improves models in this regime. An ablation ladder follows: value residuals (R1) and the Muon optimizer (R2) lift ARC-Easy by a cumulative +3.6 (52.5 -> 56.1) at a near-flat BLiMP and are kept; a diverse data blend (R3) and two logit-distillation settings (R4a/R4b) are not kept -- honest negatives. R3 pins ARC-Easy to FineWeb-Edu's educational filtering rather than raw diversity; distillation from a 1.7B teacher can reach the class-leading ARC-Easy (56.99, matching GPT-X2-125M) but only at a perplexity cost that dialing KD down then erases -- so R2 remains the best kept stack.

Sun 13 SeptArtificial IntelligenceComputation and Language
The gist
Building bigger and deeper language models usually helps them understand and generate text better, but it’s not clear how well this works for smaller models. The authors compared two versions of a language model with about 53 million and 110 million parameters, using the same training method and data. They found the larger model performed better on language tasks even though it was trained on fewer examples. They also tested some tweaks but found that certain improvements helped some tasks while others didn’t, offering a baseline for future work in this size range.
Open → 2609.14715v1

Retrieval guided fine tuning improves risk under noisy data conditions

Retrieval-Guided Fine-Tuning as Noisy Estimation: Risk bounds and Architectural Analysis

Abstract: Retrieval-Guided Fine-Tuning (RAG-FT) incorporates retrieved data directly into the training objective, but the statistical consequences of noisy retrieval during training remain theoretically undercharacterized. We study this question by modeling RAG-FT as an estimation problem in a multi-task linear regression framework, using an OLS proxy for single-layer linear self-attention to obtain finite-sample risk bounds. Under homoscedastic retrieval noise, we show that retrieval failure decays exponentially with task separation relative to noise, and derive explicit finite-sample conditions under which RAG-FT achieves lower risk than both target-only and full-corpus training. We then introduce a Distance-Proportional Noise (DPN) model, in which retrieval quality degrades with rank, and compare two estimators under the same retrieval process: the OLS proxy and the literal, uniform-weight forward pass of linear self-attention. We prove that the attention estimator's bias diverges as $Θ(n^{2q})$ even under exact retrieval, while OLS risk remains $Θ(d/n)$ for every noise exponent $q>0$. These results locate the instability not in noisy retrieval itself, but in the fixed, unweighted aggregation of the literal LSA forward pass, which reweighting by reliability empirically removes. We validate the predicted rate separation through direct simulation of the DPN model.

Sun 13 SeptMachine Learning
The gist
Training machine learning models often uses data retrieved from other sources, but this data can be noisy or imperfect. The authors studied how such noisy data affects the training process using math models and found conditions when this approach works better than training only on target data or all available data. They also analyzed different ways to combine this retrieved data, showing that some approaches can become unstable due to how they weigh the information, not just because of noise. Their findings help understand when and why using retrieved data during training is beneficial.
Open → 2609.14485v1

Feed-forward neurons signal hallucinations in large language models

NeuroActiSep: Detecting Factual Hallucinations from Feed-Forward Neurons in a Single Pass

Abstract: Hallucination in large language models reduces their reliability and slows adoption. Various white-box studies have used internal representations to detect patterns of truthfulness and factuality. A less-studied approach is to identify feed-forward neurons correlated with hallucination. We propose a method to rank feed-forward neurons at the final prompt token using a custom neuron selection dataset. We transfer the selected neuron identities to train hallucination classifiers on other factual question answering datasets. Our work provides empirical evidence that probes trained using the features from the selected neurons perform on par with probes trained on internal states. We also analyze the distribution of selected neurons and the effect of layer depth on detection performance.

Sun 13 SeptComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Language models sometimes make up facts, which makes them less reliable. The authors found specific neurons in these models that are connected to when the model hallucinates or invents information. They created a way to pick out these neurons and used them to build tools that detect when the model is likely making things up. Their method works as well as other techniques that look at more complex internal data in the model. They also studied how the position of neurons in the model affects how well hallucinations can be spotted.
Open → 2609.14448v1

Exact local attention changes improve transformer response accuracy

Exact Finite Attention Responses From RoPE Derivatives

Abstract: We derive exact local responses for attention interventions, allowing candidate edits to be scored from a cached baseline and one backward pass. The starting point is the RoPE derivative $\partial_p z(p) = A z(p)$: its integral gives the finite positional displacement, which we carry through the softmax without linearising either rotation or normalisation. The resulting predictions achieve 95.36--96.52% sign accuracy across 92,160 executed positional edits on 768 held-out prompt sets, reducing answer-margin MAE by 73.6--82.5% against the positional Jacobian and by 36.2--50.9% against zero. For simultaneous key and value edits, the same divided-difference calculus isolates the interaction term $C_{KV} = \sum_j (p'_j - p_j)\,\varepsilon_j$, which is omitted by adding separate attributions. Retaining it reduces downstream margin MAE by more than a factor of nine in every setting of a 5,120-intervention sweep across two Qwen sizes, two tasks, and multiple layers; reductions against a quadratic interaction correction are 75.9--98.5%. Exactness concerns the edited attention write; downstream predictions contract that response with a baseline gradient and are evaluated by native execution. The calculus also yields a KL certificate for local approximation error, an exact query-conditioned gradient-step representation whose curvature identifies attention-preserving query directions, and minimum-norm query control. Sparse evaluation supports candidate ranking and cache decisions under explicit local distortion criteria.

Sat 12 SeptMachine Learning
The gist
Transformers are AI models that use attention mechanisms to process information based on position. The authors found a way to exactly calculate how small changes in position affect these attention results without approximations. This method predicts changes much more accurately and efficiently, helping improve understanding of how transformers work internally. It also offers tools to control and rank these attention changes systematically.
Open → 2609.14127v1

Specialist model tuning controls student model expertise and general skills

Training Specialist Models without Reasoning Trajectories for Domain Expert Distillation

Abstract: Specialist distillation effectively transfers domain expertise to student models via teacher-generated reasoning trajectories. However, when these specialists are trained solely on question--answer pairs without explicit reasoning supervision, what governs the trajectories they generate? In this work, we show that specialist optimization implicitly selects from this latent trajectory space. To isolate and observe this latent distribution, we leverage student distillation not as a downstream goal, but as an agnostic probe---since students inherit no parameterization or optimization constraints from the specialist, inheriting only the sampled trajectories themselves. Through this probe, our empirical analysis unveils a tight governing relationship: across 27 specialist--student pairings, their specialization--generalization profiles correlate exceptionally strongly. Crucially, explicitly controlling the specialist's distributional drift systematically shifts both the teacher and its distilled student along a controllable trade-off between domain precision and general-capability retention. Across chemistry, physics, and multilingual settings, distilled students systematically reflect these specialist-induced profiles, even across divergent model families. Our findings establish a new view of specialist training: when gold reasoning is absent, tuning choices directly control the latent supervision passed to downstream models.

Sat 12 SeptMachine LearningComputation and Language
The gist
When teaching AI models specialized knowledge, the pathways they take to answer questions matter. This paper finds that even without explicit reasoning steps, the way specialists are trained strongly influences the knowledge students get from them. By analyzing how different training styles shift the specialists' focus between precise domain expertise and broader general knowledge, the authors show that these shifts are passed on to the student models. This means training choices can steer what kind of skill the student AI learns, even without clear reasoning guides.
Open → 2609.13770v1

HyperProve improves multi-step question answering with answer-guided search

HyperProve: Answer-Guided Hypergraph Expansion for Multi-Hop Question Answering

Abstract: Multi-hop question answering often fails when retrieval treats evidence as isolated matches to the original question, since the facts needed to answer a complex question are usually connected through intermediate entities, relations, and constraints. We propose HyperProve, a retrieval-augmented QA framework that addresses this challenge by coupling question decomposition with answer-conditioned expansion over a hypergraph of atomic facts. HyperProve does not use atomic facts, hypergraphs, or iterative retrieval in isolation; instead, it carries intermediate answers and supporting hyperedges as retrieval state, then uses that state to bias the next local hypergraph expansion. This design enables HyperProve to construct coherent evidence chains for final answer generation while making the retrieval process stateful and fact-centered. Across multi-hop QA benchmarks, HyperProve achieves the best overall performance in our evaluation, outperforming the strongest baselines by an average relative improvement of 6.2% in answer accuracy and 4.9% in F1.

Sat 12 SeptComputation and Language
The gist
Answering complex questions often requires piecing together multiple facts that are connected. The authors introduce HyperProve, a method that breaks down questions and builds chains of related facts step-by-step, keeping track of possible answers along the way. This helps gather more relevant evidence and improves the accuracy of final answers. Their approach performed better than strong existing methods on several benchmark tests.
Open → 2609.13768v1

Latent reasoning states hold more thoughts with better memory balance

How Many Thoughts Can a Vector Hold? The Capacity of Reasoning by Superposition

Abstract: Large language models solve hard problems through intermediate computations across multi-step reasoning. Traditional chain-of-thought encodes these computations as tokens. Recent continuous and recurrent methods instead move partial computations into fixed-dimensional latent states, where a single thought can superpose multiple alternatives. This raises a fundamental design question:what should continuous thoughts preserve as reasoning proceeds? An intuitive approach discards past computations and keeps only the current reasoning frontier. Storing more items seems to dilute states and waste limited representational capacity. We show this intuition can be incorrect. Under identical downstream computations, cumulative superposition retaining full reasoning history can require lower representational dimensions than frontier-only superposition holding only current alternatives. At fixed hidden width, this advantage allows latent reasoners to retain more valid evidence, distinguish more plausible downstream outcomes, and delay the point where compressed states turn unreliable. This counter-intuitive effect emerges because informative historical components coherently reinforce each other, while unrelated alternatives bring random interference. This perspective also answers a practical design question: how should models weight memories accumulated inside latent states when their future use is unknown? Across reusable weighted superpositions, prioritizing a small set of recent or salient items produces weakly-represented memories that bottleneck subsequent attention. Uniform cumulative weighting avoids this flaw, and we prove it is minimax-optimal for robust future reasoning. Our results turn superposition from an observed latent-space effect into a design principle: balanced cumulative memory lets a fixed representational budget support more reliable, reusable computations.

Sat 12 SeptArtificial Intelligence
The gist
This work looks at how artificial intelligence can keep track of many ideas at once when solving complex problems. Instead of just remembering what they are thinking about now, models that remember the full history of their reasoning can use their limited memory space more efficiently. The authors find that keeping all past information in a balanced way helps the system make better decisions later. Surprisingly, focusing only on recent ideas can make memory less reliable and worse for reasoning.
Open → 2609.13747v1

Automatic Hindi grammar tagging improves quantum language processing scalability

Scaling Hindi Quantum Natural Language Processing through Automatic Pregroup Supertagging

Abstract: Quantum Natural Language Processing (QNLP) uses pregroup grammars to translate grammatical structure into diagrammatic representations and quantum circuits. Recent Hindi QNLP work has shown that Hindi-specific pregroup grammars can support grammar-sensitive compositional models, but grammatical type assignment is still largely manual, limiting scalability. This paper formulates automatic Hindi pregroup supertagging as a token-level classification task. Using a manually annotated corpus of 380 Hindi sentences, we evaluate lexical, contextual, prompting-based, lexical-repair, and suffix/morphology-aware methods. Results show that simple lexical and contextual models are strong in this low-resource setting: contextual backoff achieves the best completed accuracy of 64.56\%, while raw Qwen2.5 prompting reaches only 11.65\%. Lexical repair raises LLM-assisted prediction to 64.08\%, demonstrating the value of constraining generative outputs with symbolic grammar knowledge. Diagnostic analysis further shows that seen and unambiguous tokens are much easier than unseen tokens, and suffix/morphology features improve karaka-token accuracy but not overall performance. These results show that automatic Hindi pregroup assignment is feasible and can reduce reliance on manual annotation in future multilingual QNLP pipelines.

Sat 12 SeptComputation and Language
The gist
Quantum Natural Language Processing (QNLP) tries to understand language by turning grammar rules into quantum circuits, but assigning these grammar labels by hand for Hindi is slow and limits progress. The authors studied how to automatically label Hindi words with their grammar roles using different computer models on a small set of sentences. They found that simpler models using word context worked best, reaching about 65% accuracy. This shows that automatic grammar tagging for Hindi is possible and can help expand QNLP tools to more languages without so much manual work.
Open → 2609.13721v1

Multinomial concept representations improve language model steering accuracy

MAxBench: A Multinomial Concept Recovery Benchmark

Abstract: Fine-grained control of language model behaviors (e.g., steering) is among the more actionable outcomes of interpretability research. For binary concepts such as refusal, a single direction in activation space often suffices for steering. However, many concepts are not binary: Animals and Countries contain many subcategories, each with multiple instances. For these concepts, the search space over possible representation geometries is far larger than for binary concepts; it is thus not clear what geometries are most appropriate, nor what methods are most effective at recovering them. In this work, we introduce MAxBench, a geometry-agnostic evaluation framework for multinomial concept representations based on sampling from the recovered concept representation. We use MAxBench to compare 10 localization methods (covering 5 geometry types) across 6 concepts and 4 models. Using this framework, we find that (i) affine subspaces steer more reliably and have greater recall than rank-one or linear subspaces; (ii) much of this advantage is due to better non-zero offsets rather than the choice of bases; (iii) manifold steering is competitive with the best methods when applicable; and (iv) no method consistently outperforms prompting, in alignment with prior findings on binary concepts. These findings underscore the importance of expanding the scope of interpretability research and meta-evaluation to concepts with more varied structure.

Fri 11 SeptMachine LearningArtificial IntelligenceComputation and Language
The gist
It's easier to guide a language AI's behavior when dealing with simple yes-or-no ideas, but many ideas have several parts, like different types of animals or countries. The authors created MAxBench, a tool that tests how well various methods find these complex ideas inside AI models. They found that using shapes called affine subspaces works better to steer the AI than simpler methods, and that some newer approaches also do well. However, none of the tested methods were better than just giving the AI carefully written instructions, which matches earlier findings.
Open → 2609.13072v1

Temporal recurrence reduces needed network layers with similar performance

Temporal Recurrence Favors Fewer Layers

Abstract: In streaming tasks, recurrent models can carry latent computation across time, allowing each update to build on representations produced earlier. This raises a basic question: once temporal recurrence provides sequential computation across steps, how much depth is still needed within each step? Prior work has shown that recurrence can make shallow models competitive. We instead study this question as a compute-allocation problem, varying within-step depth, expert width, and the number of parallel experts per layer across several compute budgets. For each budget, we compare the best observed recurrent and non-recurrent allocations and the performance they achieve under approximately matched per-step computation. Across Sokoban and autoregressive FineWeb language modeling, we find that temporal recurrence shifts the best observed compute allocation toward substantially fewer layers, with comparable or better performance.

Fri 11 SeptMachine Learning
The gist
Neural networks that process streaming data can remember information over time, so they don’t need to do as much work within each step. The paper studies how much layering a model needs when it already uses this kind of memory. The authors compare different setups with the same computing power and find that models using time-based memory do better with fewer layers per step. This means for some tasks like puzzles or language prediction, simpler per-step networks are enough if the model remembers past steps well.
Open → 2609.12531v1

OneLA speeds up large beam decoding for generative recommendations

OneLA: Scaling Linear-Attention Decoding to Large Beams in Generative Recommendation

Abstract: Generative recommendation (GR) relies on large-beam decoding to generate hundreds of candidate items, creating a new scaling challenge for recurrent linear attention. Existing linear attention serving systems either materialize a full recurrent state for every beam or repeatedly replay shared history, incurring substantial memory and traffic overhead. To address this, we present OneLA, a linear-attention decoding framework that exploits the shared prompt and short divergent suffixes of GR workloads. Specifically, OneLA represents all beam states using a single shared prompt-derived state and compact, append-only records of their divergent transitions. Using this representation, OneLA computes only the state information required at each decoding step, without reconstructing a full recurrent state for every beam. Furthermore, OneLA uses a lightweight ancestry index to track the transition records that make up each beam's history, allowing beams to be updated without moving or copying existing records. A fused GPU kernel further reuses the shared state across beams. Our analysis shows that OneLA achieves 1.54-2.46x end-to-end decode speedups while substantially reducing recurrent-state memory use and data movement.

Fri 11 SeptArtificial IntelligenceDistributed, Parallel, and Cluster ComputingInformation Retrieval
The gist
Generating recommendations often requires looking at many possible options at once, which can use a lot of computer memory and slow down the process. The authors introduce OneLA, a way to share information across all these options so the computer doesn't have to repeat work or store as much data. Their method uses a clever system to keep track of only the differences between options, making decoding faster and less memory-intensive. This helps recommendation systems produce lots of suggestions more quickly and efficiently.
Open → 2609.12399v1

Optimizer improves low-rank adaptation efficiency in large language models

Rank-Efficient LoRA via Joint Tangent-Space Optimization under Isotropic Curvature

Abstract: Low-Rank Adaptation (LoRA) is an effective approach for adapting large pretrained models by learning low-rank weight updates. In practice, the LoRA rank is used to control an adapter's parameter budget and representational capacity. We show that this view is incomplete: while the nominal rank determines the representational capacity, the optimizer shapes how much of that capacity is used in the induced weight-space updates. In a case study of GPT-2 adaptation with LoRA, we observe a strong rank-dependent optimizer effect. Despite using the same nominal rank, AdamW often produces per-step updates with concentrated singular spectra and low effective rank, whereas Muon uses a richer set of directions and benefits more consistently from increasing LoRA rank. These observations motivate ISO-LoRA, an optimizer that couples the LoRA factor updates through spectral descent on the induced tangent perturbation in weight space. ISO-LoRA promotes updates that distribute energy more evenly across singular directions, improving rank utilization while preserving compatibility with the LoRA parameterization. We complement this design with theoretical guarantees showing that ISO-LoRA can achieve higher effective rank than standard factor-wise optimizers through a one-step analysis under a stylized spiked-gradient model. We validate this design on language-model adaptation across 0.1B-7B-parameter models, where ISO-LoRA improves effective rank and downstream performance, with the strongest gains at moderate-to-large LoRA ranks. Our results highlight rank utilization as a key factor in LoRA optimization and suggest that optimizer design offers an important path toward stronger parameter-efficient adaptation.

Thu 10 SeptMachine Learning
The gist
Large language models can be adapted to new tasks efficiently by tweaking small parts of their internal weights using a method called LoRA, which controls how complex the changes are. The authors found that not only the size of these changes matters but also how the optimizer directs them. They introduced ISO-LoRA, a new optimizer that better spreads out the changes, making the adaptation use its capacity more fully. Testing showed that this approach leads to improved performance on language tasks, especially when using moderately large updates.
Open → 2609.12123v1

Non-language data helps train language models but with limits

Structural priors for data-efficient language learning

Abstract: Efficient language learning requires methods to reduce the reliance on large data and computational resources. We investigate structural transfer: First training models on non-language data to induce useful priors for natural language. This approach is a form of weight initialization for multilingual language modeling. We evaluate transfer via next-token-prediction loss, weight shifts in the model, and downstream linguistic benchmarks. Several symbolic data types - notably music, probabilistic grammars, and cellular automata - yield lower language-modeling loss than random initialization. These gains coincide with smaller weight shifts during subsequent language training, suggesting that structural transfer positions models in a more favorable region of the parameter space. However, a lower loss does not translate consistently into better downstream linguistic performance, and transfer from non-language data is less efficient than additional language data. We conclude that non-language data can serve as a partial substitute for language data for the training objective of next-token prediction but does not reliably support broader linguistic generalization.

Thu 10 SeptComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Training language models usually needs lots of text data and big computers. This paper studies if training on other kinds of structured data like music or patterns can help language learning. The authors found that starting training on these non-language data reduces the work needed later and improves some training signals. But, this approach does not always help the models perform better on language tasks and is not as effective as just using more language data. So, other data types can partly replace language examples but don’t fully teach language skills.
Open → 2609.11505v1

Calibrated uncertainty scores improve model efficiency and accuracy

Calibration-Aware Uncertainty Cascades for Efficient Heterogeneous Model Collaboration

Abstract: Heterogeneous model collaboration seeks to exploit the complementary strengths of different models to balance predictive performance and inference cost. Existing approaches typically rely either on trained routers, which tie routing decisions to a fixed task and model pool, or on raw-confidence cascades, whose thresholds lack consistent reliability semantics across heterogeneous models. Consequently, these approaches adapt poorly to changing model pools and deployment budgets. We propose Calibration-Aware Uncertainty Cascades (CAUC), a simple post-hoc framework that independently calibrates each model's confidence and selects deployment policies using validation data. The resulting calibrated confidence scores establish a common reliability scale for accepting an early prediction, invoking a stronger model, or selectively combining model outputs. This unified decision criterion decouples deployment policies from any particular model pool or operating budget. We further show theoretically that calibration gives confidence thresholds an explicit selective-risk interpretation, whereas uncalibrated scores offer no comparable reliability guarantee. Extensive experiments demonstrate that, across six language benchmarks, CAUC achieves an average relative accuracy improvement of 1.9% over strong-model-only inference while avoiding approximately 47% of strong-model calls. On image classification benchmarks, it maintains or improves predictive performance while reducing measured GFLOPs by up to 57%.

Thu 10 SeptArtificial Intelligence
The gist
Getting the best results from multiple AI models can be tricky because their confidence scores don’t always mean the same thing. The paper presents a way to adjust each model’s confidence, so their scores are reliable and can be compared fairly. This helps decide when a simpler model is good enough or when to use a stronger one, without sticking to fixed rules. Their method lets systems save time and computing power while keeping or improving accuracy on language and image tasks. It works well across different models and changing conditions.
Open → 2609.11446v1

Anonymizing data affects large language model performance differently

On the Impact of Anonymization on the Performance of Large Language Models

Abstract: As large language models are increasingly deployed in sensitive domains, anonymizing input data to protect personally identifiable information has become a critical practice. However, the impact of this anonymization on model utility is not well understood. This paper presents a systematic empirical study of the trade-off between privacy and performance. We evaluate five prominent language models across eleven diverse benchmarks, comparing their performance on original versus pseudonymized inputs. Our results reveal that while anonymization generally degrades performance, the effect is highly nuanced. We find that more capable models, such as Qwen2.5-72B and GPT-4o mini, suffer the largest performance drops, suggesting a stronger reliance on specific entity information. The impact is also task-dependent: performance on TruthfulQA improves with anonymization, while retrieval-focused tasks like RGB experience a catastrophic decline. Further experiments show that reversible anonymization techniques that preserve entity uniqueness significantly outperform irreversible ones like redaction, and that explicitly prompting models about anonymization offers no discernible benefit. We conclude that anonymization is not a one-size-fits-all solution and must be co-designed with the model and task in mind to balance privacy and utility effectively. Our findings provide a crucial baseline for developing more robust, privacy-aware AI systems.

Thu 10 SeptComputation and LanguageArtificial Intelligence
The gist
Protecting private information by anonymizing data before using large language models often reduces the quality of their responses. The authors show that the impact varies widely depending on the model and task. Surprisingly, more advanced models lose more accuracy when data is anonymized, and some tasks actually benefit from it. They also find that anonymization methods keeping each entity’s uniqueness help models perform better than simply erasing information. This means keeping privacy while maintaining usefulness requires careful choice of both method and model.
Open → 2609.11335v1

Diffusion vision-language models improve answers by adapting reasoning length

Routing by Reasoning Need: Trajectory-Aware Decoding Control for Diffusion Vision-Language Models

Abstract: Diffusion vision-language models generate answers through iterative refinement, exposing intermediate answer trajectories that can be inspected and controlled at inference time. However, this controllability creates a reasoning-need mismatch, where a universal generation length is applied to questions with different reasoning demands. Visually closed questions may be harmed by continued refinement after a stable answer has formed, whereas reasoning-sensitive questions may be harmed by premature commitment. We formulate this problem as reasoning-budget mismatch and study it in LLaDA-V. Rather than choosing a universal generation length, our training-free controller routes each example to early commitment, baseline preservation, or reasoning-supportive decoding using trajectory signals from answer closure, commitment evidence, and representation revision pressure, without using ground-truth answers. Across answer-focused, mixed-reasoning, and CoT-sensitive benchmarks, routed control improves robustness over fixed long decoding, pure short decoding, and single-rule interventions. The gains are not explained by shorter outputs alone. Answer-closed examples often benefit from commitment, whereas CoT-sensitive examples require preserving or supporting intermediate reasoning. Taken together, these results suggest diffusion VLM decoding should route inference-time control by the state suggested by the observed trajectory instead of relying on a universal decoding length.

Thu 10 SeptArtificial Intelligence
The gist
Some AI models answer questions by slowly refining their guesses step by step. But using the same number of steps for all questions can cause problems: simple questions may get overthought, while complex questions may be cut short. The authors studied this problem with a model called LLaDA-V and created a way to watch how the answer changes during thinking. Their system decides when to stop early, keep going normally, or focus on detailed reasoning, based only on signals seen without knowing the true answer. Tests showed this approach gave better, more reliable answers across different types of questions.
Open → 2609.11315v1

Structured pruning method improves large language model compression without calibration

LILA: Calibration-Free Structured Pruning of Large Language Models via Latent Spectral Geometry

Abstract: Structured pruning of large language models (LLMs) offers hardware-efficient compression, yet existing methods require calibration data, gradient computation, or large auxiliary policy networks at pruning time. LILA (\emph{Latent-Informed Layer Analysis}) scores neuron importance via the Kolmogorov--Smirnov (KS) distance between empirical singular value distributions of the full and neuron-ablated feed-forward network (FFN) weight matrix, providing a closed-form spectral rule requiring no training, calibration data, or auxiliary network. Without any fine-tuning, LILA surpasses PruneNet (45M-parameter RL policy) by 1.57~pp in zero-shot accuracy on LLaMA-2-7B at 25\% sparsity, and outperforms WikiText-2-calibrated SliceGPT by up to 6.0~pp across all sparsity levels, while preserving the original architecture. After one epoch of LoRA recovery fine-tuning, LILA achieves highly competitive performance, matching the heavily calibrated SliceGPT baseline to within a 0.48~pp margin across LLaMA-2-7B and Phi-2, despite using zero calibration data. A Neural Tangent Kernel analysis confirms a 22$\times$ reduction in functional distortion versus random pruning, providing theoretical grounding for the spectral importance criterion. Finally, extending LILA to dynamically allocate sparsity budgets via KS-scores yields state-of-the-art generative preservation at moderate compression, while uncovering fundamental single-layer architectural bottlenecks at higher compression regimes.

Thu 10 SeptMachine LearningComputation and Language
The gist
Large language models are often too big and slow to use efficiently, so experts try to shrink them by removing less important parts. Existing ways to do this need extra data or training, which can be complicated and time-consuming. The authors of this paper introduce LILA, a new method that measures how important parts of the model are by comparing mathematical patterns in its weights, without any extra data or training. LILA prunes models effectively while keeping their original design and shows better or similar performance compared to other methods.
Open → 2609.11163v1

Continuous and discrete flow methods reveal new paths for categorical generation

Flow Duality and Source Geometry for Categorical Generation

Abstract: Continuous and discrete flow matching are usually treated as separate constructions. This paper identifies a duality between them: projecting continuous convex-interpolant paths with one-hot targets through a position-wise argmax yields discrete convex-interpolant paths. The result requires source laws with appropriate coordinate symmetry and boundary regularity, and it makes the continuous source distribution an explicit design choice for categorical generation. We derive the induced discrete interpolation behavior for Gaussian, bounded-uniform, and centered negative-exponential sources, showing that different source geometries lead to qualitatively different transition timing and vocabulary-size dependence. Small visual diagnostics and a short language-modeling pilot suggest that these source-design effects can also appear in learned transports and early generative quality.

Wed 9 SeptMachine Learning
The gist
Generating categories like words or labels can be done in different ways, either smoothly or in steps. This paper shows these two ways are connected through a neat mathematical relationship involving a choice called the source distribution. The authors found that picking different starting shapes changes how the transition between categories happens and how big the vocabulary can be. Their tests hint these findings might help improve language models and early stages of category generation tasks.
Open → 2609.10863v1

Transformer models mirror traditional features in multilingual readability tasks

Analyzing Traditional and Neural Approaches to Multilingual Readability Assessment

Abstract: Transformer-based models excel at Automatic Readability Assessment (ARA), yet feature-based models remain in active use because their predictions tie back to linguistic properties. This matters because readability labels are subjective and rater-dependent, so high accuracy on noisy ground truth may reflect surface patterns rather than the linguistic structure that defines difficulty. We test whether transformers internalize the same features as traditional models across Arabic, English, French, Hindi, and Russian using the ReadMe++ dataset. Shapley Additive Explanations (SHAP) identify the features driving traditional classifiers, which we then use as TCAV concept sets to probe multilingual XLM-R and language-specific encoders. Transformers recover surface-length, syntactic, and lexical-diversity signals, and reflect the ordinal CEFR structure of the traditional models. Alignment varies by model family, language, and layer, with language-specific encoders tracking traditional models more clearly than XLM-R. High linear separability does not always imply directional influence, limiting linear probing for count-based readability features.

Wed 9 SeptComputation and Language
The gist
Assessing how hard a text is to read often relies on either classic methods using linguistic features or newer AI models called transformers. This paper looks at whether transformer models understand the same language features as traditional methods in multiple languages. The authors find transformers do pick up on features like sentence length and vocabulary variety that affect readability. However, how well they track these features depends on the model type, language, and the model’s internal layers.
Open → 2609.10792v1

Language model predicts concepts to improve text generation efficiency

NCP-ArchPreview Technical Report: Moving towards Latent Space Language Models through Next Concept Prediction

Abstract: We introduce NCP-ArchPreview, a latent-space language model that pushes autoregressive pretraining beyond standard next-token prediction (NTP). Alongside NTP, the model learns through Next Concept Prediction (NCP) to predict discrete concepts that span multiple tokens, introducing an explicit and more challenging concept-level objective while preserving standard token-level autoregressive generation. NCP-ArchPreview builds a latent space by constructing a product-quantized concept vocabulary directly from its hidden states, and subsequently learns to predict future concepts via a dedicated Concept Module. These predicted concepts are then fed back to the token level to guide subsequent generation, with NTP and NCP trained jointly end-to-end. We scale this architecture to 8.9B parameters and train it on 5.73T tokens from the Dolma-3 dataset, marking the largest demonstration of a latent-space language model to date. Remarkably, by consuming only 51.3% of the total training tokens, NCP-ArchPreview achieves the final pretraining loss of OLMo-3-7B. Following full pretraining, it outperforms OLMo-3-7B by 2.45 points on the downstream macro-average, including a notable 5.99-point gain on GSM8K. Controlled experiments isolate a clear progression of performance gains stemming from both the latent architecture and the NCP objective. Furthermore, utilizing only 85% of the standard computation, NCP-ArchPreview approaches the training loss of a strictly parameter-aligned 8.9B baseline. The learned latent space remains highly valuable after the pretraining stage: updating just the 17M-parameter VQ module yields a novel, lightweight interface for domain adaptation, while a simple injection of concept representations into a DFlash2 drafter improves the mean accepted length by 4.17% with negligible overhead.

Wed 9 SeptComputation and Language
The gist
Large language models usually learn to predict the next word in a sentence. This paper presents a model that also learns to predict larger chunks of meaning called concepts, which helps it understand and generate text better. The model builds a special set of concepts from its internal thoughts and uses these to guide the next word choices. This approach leads to better performance with less training data and can be adapted easily for different topics later on.
Open → 2609.10715v1

Training paths shape circuit removal in small transformer models

Training Trajectories Determine Circuit Removability in Annealable Soft-Prior Transformers

Abstract: Soft positional priors can help small Transformers learn retrieval circuits, but it is unclear whether the resulting circuits remain functional once the prior is removed. We test this with an annealable soft-prior Transformer whose attention biases can be learned, faded, or zeroed during training and evaluation. On associative recall, unforced models perform well with the prior active ($0.772 \pm 0.020$) but collapse at zero gate ($0.095 \pm 0.009$). Smooth fade-to-zero training preserves high zero-gate accuracy ($0.734 \pm 0.028$), whereas forced-zero training, hard switching, and post hoc continuation fail to recover the same effect. The pattern also appears on Markov induction. Linear regression ICL provides a boundary case because zero-gate training can learn that task directly. Mechanistic traces show that circuit consolidation occurs after the gate reaches zero, even though the responsible heads vary across seeds. These results suggest that circuit removability in small discrete retrieval tasks depends on the training trajectory, not just the final architecture.

Wed 9 SeptMachine LearningNeural and Evolutionary Computing
The gist
Small Transformer models can use helpful hints during training to learn how to retrieve information, but it’s unclear if these tricks stay useful when removed later. The authors tested a method where the model slowly loses these hints during training, which helped keep its skills strong even without the hints. However, if the hints were just switched off suddenly or removed at the end, the performance dropped. This shows that how a model is trained over time matters as much as its final design.
Open → 2609.10287v1

Most transformer decisions rely on a small set of key components

Through the Looking Glass: Directly Reading and Writing Transformers

Abstract: How many of a transformer's components decide a token? Counted by the absolute value of each unit's and channel's contribution to the logit, one prediction rests on thousands to hundreds of thousands of them. But contributions are signed, and across eighteen models the mass pushing away from the predicted token is a median of seven times the mass carrying it. Divide by the net and the count is dozens: on the baseline, 53 components carry ninety percent of a prediction, 13 it cannot survive losing, and 8 suffice to produce it alone. Across twelve models trained elsewhere, 124M to 7B parameters, the sufficient set runs from two components to sixteen, and what a prediction draws on, followed all the way back, is one to three percent of the model, a share that does not grow with size. Three quarters of a layer's update is a fixed linear map of the state it received. Everything is read from the model's own parameters and activations, with nothing trained or fitted, and it names a component on both sides: what it writes, from the predictions it drives, reaching close to half of every model; what it reads, from its weights in the frame of its own layer, at 58.9 percent above chance over its eight strongest inputs. Sorting the remainder by upstream source yields grammatical categories the embedding cannot see. A name can be acted on. An association the model does not hold installs into one spare unit, key and value read from the weights, for a quarter of a percent of held-out loss, a fortieth of what a rank-one update costs. An installed attention head and a unit two layers above it make an edit fire only where a token occurred earlier in the context, and a unit the model trained for itself is driven from two layers upstream, 86 percent of the effect passing through it. An order-preserving activation puts a unit's inputs at the instrument's ceiling, at the price of a two-part install.

Wed 9 SeptComputation and LanguageMachine Learning
The gist
Transformers, a type of AI model used for language tasks, make predictions based on many internal parts called components. This work found that while thousands of parts contribute to each prediction, only a small handful are really needed to produce or destroy it. The authors showed that just a few components—sometimes as few as two—can explain most of what drives a prediction. They also demonstrated how specific components can be read and modified directly to change model behavior without retraining. This sheds light on how transformer models represent information and make decisions.
Open → 2609.10210v1

Reading transformer differences reveals model-specific token patterns

Contrastive Projection: Reading Transformer Internals by Differencing Logit Lenses

Abstract: Reading a transformer's internal states in token space is easy to do and hard to trust: a logit lens on a single hidden state is dominated, at intermediate layers, by the generic tokens the model would predict for almost any input. We read the difference instead. Subtracting two closely matched prompts' hidden states and projecting through the unembedding cancels the shared component and surfaces what separates them, an operation equivalent to reading a RepE/ActAdd steering vector through a logit lens. Built into a training-free tracer that reads at every position, sub-layer, and head and averages over designed baselines, it traces a compound- noun MLP->attention chain in Phi-2, confirmed there by activation patching, with the same distinction recovered across three architectures by readout and probe rather than by patching; it reads what retrieval surfaces for real versus fictional entities, and reads metaphor as a set of domain-to-domain mappings rather than a single figurativity feature. A cross-seed control marks the boundary: across five networks differing only in initialization, the same distinction surfaces as almost entirely different tokens (top-10 overlap 0.08). What a computation looks like in token space is network-specific; the distinction it draws is not

Wed 9 SeptComputation and Language
The gist
Transformer models can be hard to understand because their internal states often reflect common predictions rather than specific details. The authors show that by comparing the differences between similar inputs inside the model, they can highlight what truly distinguishes those inputs. This approach helps reveal how models process complex ideas like nouns, real versus fictional entities, and metaphors. Even though different models focus on very different tokens, the key distinctions they make are consistent.
Open → 2609.09902v1

Balanced small-sample sampling causes exact degeneracy in text embeddings analysis

Exact Degeneracy Under Balanced k-Shot Sampling:Consequences for Small-Sample Discriminant Analysis on LLM Embeddings

Abstract: Balanced k-shot sampling draws exactly k labeled examples per class. We show that it induces an exact, provable degeneracy in a family of small-sample discriminant estimators. Under balanced sampling, the within-class scatter operator of Kernelized Linear Principal Component Discriminant Analysis (KLPCDA) is not merely rank-deficient but exactly a scaled orthogonal projector. We derive the consequences in closed form: two of KLPCDA's seven variants have every signal eigenvalue exactly equal, so their eigenvector selection criterion is provably indifferent rather than ill-conditioned, and a third has a provably void objective. This follows from the estimators' construction, not any dataset; we confirm it on frozen sentence embeddings and, separately, on residual-stream activations from a decoder-only generative model. An in-formula tie-break repairs the two repairable variants, with recovery gated by class count: the residual subspace constraint costs 5x more on few-class than many-class datasets (p=0.000001). We then evaluate the repaired framework on few-shot text classification on frozen LLM embeddings (n much smaller than d, up to 4096), across four datasets, three embedding sizes, and three trained baselines (SetFit, LoRA, in-context learning). A properly cross-validated logistic-regression probe still beats every KLPCDA variant on three of four datasets, at every embedding size; guidance carried from pixel, vibration-signal, and gene-expression data does not directly generalize to this feature space. Three independent geometric separability metrics fail to explain why one high-dimensional decoder-based embedding model underperforms smaller bidirectional encoders, ruling out anisotropy; the gap is substantially an estimation-efficiency effect, not a permanent ceiling, closing by more than 80% when the support set grows from k<=10 to k=30-50 (p=0.00195, both many-class datasets).

Wed 9 SeptMachine Learning
The gist
When you pick the same number of examples from each category to teach a computer how to tell categories apart, some math methods break down exactly rather than just approximately. The authors show this happens systematically for certain analysis tools used with language model embeddings, causing some math parts to become equal or void. They fix this with a small change and test it on text classification tasks, finding that simple logistic regression often works better on these embeddings. They also show that more examples helps close gaps in performance, especially when classes are few.
Open → 2609.09860v1

Supervised fine-tuning improves math reasoning by ignoring easy and hard tokens

Which Tokens Should SFT Actually Learn? A Token-Trimming Perspective on Mathematical Reasoning

Abstract: Supervised fine-tuning (SFT) applies a uniform cross-entropy loss to all target tokens, even though different tokens provide unequal learning signals for mathematical reasoning. This uniform treatment can over-sharpen already mastered tokens while amplifying learning pressure on uncertain, low-confidence tokens, leading to suboptimal training dynamics. We propose Trimmed Logit-Gap SFT (TrimSFT), a simple token-level reweighting method that scales the SFT loss according to the logit gap between the gold token and its strongest competitor. TrimSFT trims supervision away from both extremes: tokens already mastered (large logit gap) and tokens weakly supported by the current model (small or negative logit gap), concentrating learning within an intermediate logit-gap region between them. We instantiate this principle with a Gaussian weight centered at margin m with bandwidth τ, requiring no reference model or additional forward pass. We evaluate TrimSFT on six base models from the Llama, Qwen, and DeepMath families across five mathematical reasoning benchmarks. TrimSFT consistently improves over standard SFT, achieving the best average performance on five out of six models, with gains of up to +26.9 points over SFT on MATH500. Further analyses show that the bandwidth τ matters more than the exact margin location, and that half-trim variants that remove supervision pressure from only one side yield inferior trade-offs. A token-level logit-gap distribution analysis suggests that TrimSFT reshapes model confidence in a more balanced way than uniform SFT or monotonic reweighting methods. These results suggest that reasoning SFT can benefit from trimming both extremes rather than treating all tokens uniformly.

Wed 9 SeptArtificial Intelligence
The gist
Training AI models to solve math problems usually treats all parts of an answer equally, but some parts are easier or harder for the model to learn from. The authors suggest focusing training only on the moderately difficult parts, ignoring those the model already understands well and those it gets very wrong. This method, called TrimSFT, changes the model's learning focus based on how confident it is about each token. Tests show that TrimSFT helps models perform better on various math tests.
Open → 2609.09707v1

Osprey boosts language model drafting speed and accuracy across tasks

Osprey: Target-agnostic Pre-training Makes Stronger Drafters in Speculative Decoding

Abstract: Speculative decoding is critical for accelerating LLM inference. However, the speedup is fragile: drafters are typically trained against a narrow distribution for a single target model, and their acceptance rate collapses under workload shifts. This is a striking inversion of modern LLM development, where target models are valued precisely for the broad generalization they acquire through large-scale pretraining. We argue that the natural remedy, pretraining, has been hard to apply to drafters because existing recipes are target-specific: the drafter consumes the target's hidden states and is distilled on the target's logits, so pretraining must be repeated for each target. We introduce Osprey, which instead bootstraps drafters from off-the-shelf pretrained small language models, treating broad pretraining as a reusable, target-agnostic asset and reducing per-target work to a lightweight adaptation step. Realizing this requires overcoming two challenges: small LMs are far deeper than a latency-bound drafter can afford, and their pretrained computation must remain intact while the drafter learns to ingest target hidden states and emit tokens in the target's vocabulary. Osprey addresses both by pruning to a shallow backbone, restoring its language-modeling capability with target-agnostic next-token pretraining, and adapting it to each target through vocabulary alignment, zero-initialized QKV expansion, and distillation from the target model's output distribution. Empirically, a single pretrained Osprey backbone transfers across targets and improves mean acceptance length by 16.1% for Qwen3-8B, 21.2% for Llama-3.3-70B-Instruct, and 22.7% for the 229B MiniMax-M2.5 (with 17.5% higher tokens per second), with the largest gains on out-of-domain and multilingual data. Our code is available at https://github.com/LeanModels/Osprey.

Tue 8 SeptComputation and Language
The gist
Generating text quickly with AI language models is often slowed down by a part called the drafter, which is usually trained for just one target model. This means when the task changes, performance drops. The authors introduce Osprey, a method that uses a small pretrained language model as a general drafter that can easily adapt to different target models. This approach makes drafting faster and more reliable across various models and types of text, especially for ones that are new or in different languages. Osprey improves both speed and the quality of text acceptance in experiments.
Open → 2609.09338v1

Tracking how large language models reason over time and answers

Answer-Distribution Trajectories: A Stochastic-Dynamics View of LLM Reasoning

Abstract: Chain-of-thought reasoning provides a structured computation between a model's input and final answer. Yet it is often evaluated through endpoint accuracy, which ignores the path taken to reach that answer. An emerging line of work addresses this limitation using entropy profiles, which track how uncertainty evolves over the reasoning process but do not reveal which competing hypotheses account for that uncertainty. We introduce answer-distribution trajectories, a stochastic-dynamics-inspired representation that tracks the model's full predictive distribution over answers as reasoning unfolds. As a strictly finer representation than endpoint and entropy summaries, answer-distribution trajectories enable us to characterize a trace through a dynamical reasoning profile spanning exploration, revision, motion, and commitment, and to distinguish different dynamical mechanisms of reasoning success and failure. Across sixteen open-weight language models and four reasoning benchmarks, we show that traces with the same endpoint and similar entropy profiles can exhibit substantially different reasoning dynamics. We further find substantial variation in these dynamics both within and across models and tasks, with different objectives favoring different dynamical profiles. Additionally, we show that training and inference choices systematically reshape these profiles. Our results suggest that answer-distribution trajectories provide a rich framework for analysing and evaluating the dynamics of LLM reasoning.

Tue 8 SeptArtificial IntelligenceComputation and LanguageInformation Theory
The gist
Evaluating AI models by only their final answers misses important details about how they think. The authors introduce a way to track the full range of answers a model considers while reasoning, not just the final choice or overall uncertainty. This lets them see when the model is exploring options, changing its mind, or getting confident. Their method reveals different patterns of success and failure across various models and tasks, helping us better understand AI reasoning processes.
Open → 2609.09030v1

Transformer length generalization improves with compressed string analysis

Length Generalization for Transformers via Compression

Abstract: Recent advancements in transformer length generalization theory enable us to reliably predict when a transformer can learn to solve a task. In particular, the C-RASP hypothesis (a formalized version of the so-called RASP-l conjecture) posits that transformers length-generalize on a task if and only if a solution is expressible in the C-RASP language. While this hypothesis has strong empirical validation, theoretical problems arise from the fact that no computable length generalization bounds exist for C-RASP, alongside the discovery of seemingly contradictory experiments. To address these problems, we refine the C-RASP hypothesis utilizing the recently-proposed fragments C-RASP+ and C-RASP1. These fragments have computable length generalization bounds, though in the worst case requiring an extremely large (double exponential) sample size. It is an open question whether these sample size bounds are tight. In this paper, we resolve this open question by providing an exponentially tighter bound. In doing so, we show a polynomial length generalization bound for transformers if we adopt compressed strings, via a novel connection to power words. As an application, we show how this yields a fine-grained analysis of the C-RASP conjecture that resolves contradicting experimental evidence against it.

Tue 8 SeptMachine LearningFormal Languages and Automata TheoryLogic in Computer Science
The gist
Understanding how transformers handle tasks with longer inputs is tricky because previous theories had unclear limits. The authors improved the theory by showing that when input strings are compressed cleverly, transformers can learn to handle longer inputs with much less data than previously thought. This new insight connects complex math ideas about string compression to transformers, helping explain some earlier conflicting experiments. Their work offers clearer predictions on when transformers will succeed with longer inputs.
Open → 2609.08851v1

Chimaera blends graph experts to boost cross-task graph learning

Chimaera: A Mixture-of-Graph-Experts Architecture for Cross-Task and Cross-Dataset Graph Learning

Abstract: Designing foundation models for graphs is challenging due to the irregular structure of graphs and the different sizes and characteristics of embeddings. Chimaera integrates mixture-of-experts with graph foundation models (GFM). It integrates different GFM architectures, such as graph prompts and linear GNN models. Large language models are used to generate embeddings, and experts can be trained and combined following different strategies, GFMs, embeddings, etc. Furthermore, Chimaera extends existing linear GNNs to support link-level and graph-level tasks in addition to node-level tasks. Empirical analyses are performed on same-task and cross-task experiments with node, link, and graph classification tasks using six benchmark text-attributed graph datasets. The experiments demonstrate the effectiveness of Chimaera and its capabilities for transfer across tasks and datasets. Further insights include the need to use both large and small language models to generate embeddings for the experts, a strong cross-task transferability of simple but effective linear GNNs, and using few samples only to provide strong results.

Tue 8 SeptMachine Learning
The gist
Graphs are complicated data structures that are hard to analyze because their shapes and connections vary a lot. The authors created Chimaera, a system that combines different graph learning tools and models, including simple and complex ones, to better understand graphs across different tasks and datasets. Chimaera uses both large and small language models to create effective data features, and it can work on different types of problems involving nodes, links, or whole graphs. Their tests show that Chimaera performs well and can learn from a few examples to apply knowledge to new tasks and datasets.
Open → 2609.08709v1

Group arrangement influences evidence strength in language models

Record Grouping Controls Evidence Weight in Language Models

Abstract: Retrieved records are presentation units; a supplied partition determines which records enter a language model as one evidential contribution. We characterize the invariant group-content state that removes within-group copies while retaining complementary canonical content, show that equal group counts can encode different evidence states, and derive a sharp content-aware partition-error bound. Given a supplied partition, our pre-generation representation deduplicates and aggregates content within groups and bounds each group's contribution. Across 104,402 trials and 6 public checkpoints, a central natural-text intervention finds that content-fixed false splits add 10.27-32.66 percentage points and false merges remove 9.13-31.79 points; a matched six-slot control retains the positive direction in all 16 cells. In a new 48-item controlled campaign panel, changing the supplied partition produces measurable, checkpoint-dependent decision shifts across all four models, and the balanced mirror design exposes substantial order interactions. Together, the theory and experiments establish the supplied partition as a controllable pre-generation representation variable and characterize its checkpoint-dependent behavioral effects.

Tue 8 SeptComputation and Language
The gist
The way pieces of information are grouped before feeding them into language models changes how strongly the models use that information to make decisions. The authors find that grouping can make the model weigh evidence differently, even when the content is the same. They developed a method to remove duplicate information within groups and showed that splitting or merging groups incorrectly changes model accuracy. Their tests across multiple models confirm that how data is grouped before input can affect model behavior.
Open → 2609.08698v1

SSMs and transformers use different spaces but encode concepts similarly

Global Divergence, Local Convergence: Representation Geometry in SSMs and Transformers

Abstract: Recent state-space models (SSMs) such as Mamba achieve language modeling performance comparable to transformers despite relying on fundamentally different architectures. This raises an important question: how do these structural differences influence the geometry and functional nature of their internal representations? We study this question through a multi-scale analysis of representations in transformers, SSMs, and hybrid architecture. First, we find that SSMs distribute their representational information evenly across all dimensions, whereas transformer representations are heavily dominated by a single principal direction. By evaluating hybrid architectures, we observe that the representation space becomes increasingly skewed toward a single dominant direction after each attention layer. Next, we explore how the different geometric spread of representations impacts representational capacity through compressibility. Surprisingly, we find that despite their contrasting geometric structures, both architectures exhibit tightly matched effective capacities. We further investigate whether this skewed geometry affects how concepts are encoded. Using rank-constrained probes, we demonstrate that both architectures encode concepts in subspaces of surprisingly similar dimensionality. Furthermore, we demonstrate that the transformers' dominant principal direction does not inherently encode more conceptual information. Finally, we zoom in and examine the alignment between manifolds, either by analyzing representations of specific topics or by looking at the nearest neighborhoods of tokens, and find that they are highly aligned. Ultimately, our analysis suggests that while transformers and SSMs induce different usage of latent space, they display a striking functional convergence at the level of local semantic manifolds.

Tue 8 SeptComputation and Language
The gist
Different AI language models, like transformers and state-space models (SSMs), have different internal structures. The authors found that while transformers focus their information in one main direction inside their 'brain,' SSMs spread it out evenly. Despite these differences, both still store knowledge in similarly sized ways and group ideas in very similar local patterns. This means their overall function in understanding language is surprisingly alike, even if their inner workings look different.
Open → 2609.08692v1

Outcome indexed attention vectors stabilize multi outcome learning models

Why shared attention vectors fail: a case for outcome-indexed tuning

Abstract: Dimensional attention in learning is often implemented as a globally shared attention vector, where each stimulus dimension corresponds to a single scalar. These scalars are learned by models through gradient-descent on error, where predictive features acquire more salience. We show that under multi-outcome learning, where models predict more than one outcome, this shared vector becomes unstable; it collapses to its bounds and prevents the models from learning meaningful attentional tunings for learning and generalization. We address this by introducing an outcome-indexed attentional matrix that converts globally shared attentional tuning into an outcome-indexed representation. We present an analysis of the unstable shared vectors and derive the conditions under which it holds. Empirically, three synthetic experiments benchmark the proposed attention matrices and show that they converge to meaningful representations, something shared attention vectors fail to do. These results suggest that outcome-indexed attentional matrices are a general fix for gradient-based attentional processes, which improves models of learning under multi-outcome conditions.

Tue 8 SeptMachine LearningNeural and Evolutionary Computing
The gist
Sometimes computer programs learn to pay attention to important signals by using a shared list of weights. But when the program has to predict many different things at once, that shared list breaks down and stops working properly. The authors show this happens because the shared attention becomes unstable during training. They fix the problem by creating separate attention weights for each thing the program predicts, which helps the learning process and makes the program better at understanding patterns. Their new method works well in tests where the old method failed.
Open → 2609.08615v1

Sinhalese word meanings change unevenly over centuries

Dynamics of meaning: Towards the Evaluation of Diachronic Semantic Change in Sinhala

Abstract: Tracking semantic change in low-resource languages across extensive historical timelines presents significant challenges due to data scarcity and the limitations of static embedding alignments. This study investigates the diachronic evolution of the Sinhala language from the 13th to the 20th century using a multi-stage computational framework. We first align century-specific Word2Vec and FastText embeddings using Similarity Matrix Based Alignment (SMA) and Orthogonal Procrustes (OP) techniques, finding that OP alignment provides more stable neighbourhood tracking for identifying temporal similarity dips. To move beyond aggregate measures, we introduce a Bidirectional Semantic Impact Pruning approach using contextualised embeddings from a fine-tuned Llama-3.1-8B. By applying Leave-One-Out (LOO) diagnostics, we attempt to isolate influential sentences to distinguish between systemic semantic shifts and transient polysemic expansion. Our results show that semantic drift in the fine-tuned Llama-3.1-8B is not evenly distributed across all usages. Instead, a significant part of the change is driven by a smaller set of high-impact contextual instances, rather than gradual and uniform change across all occurrences. This work provides a preliminary framework for diachronic analysis in low-resource contexts, highlighting the trade-offs between model sensitivity and data availability.

Tue 8 SeptComputation and Language
The gist
Tracking how word meanings change over a long time is hard, especially for languages with little data like Sinhala. The authors used computer techniques to study Sinhala from the 1200s to the 1900s. They found that word meaning changes often happen in specific important uses, rather than slowly and evenly everywhere. Their approach helps understand language change even when data is scarce.
Open → 2609.08609v1

Training objective not architecture drives attention sink in long context models

Do New Attention Mechanisms Actually Fix Attention Sinks at Million-Token Context?

Abstract: Long context language models now advertise windows of one million tokens, but two habits limit how much of that window is used. Attention heads with nothing useful to read still spend their budget on the first token, which is called the attention sink, and where a fact sits in the context changes whether the model finds it. Gated attention cut first token attention from 46.7 percent to 4.8 percent at NeurIPS 2025, and Kimi K3 pairs that idea with Kimi Delta Attention and Attention Residuals behind a one million token window, eight times past the range where these diagnostics have been reported. This paper asks whether the fix survives that jump. We build SinkProbe, a suite that measures sink mass, massive activation, position resolved recall and the recency gap, and apply it to four small models that differ only in how they mix tokens and depth. Three results follow. The training objective produces the sink, not the architecture. Gating did not reproduce its published effect at our scale. Sink mass, activations and position bias moved independently. Code, data and the measurement protocol are released at https://github.com/sararizwan7/Attention-Mechanisms-in-1M-Context-Window

Tue 8 SeptComputation and LanguageArtificial Intelligence
The gist
Some language models look at a huge amount of text at once, but they often get stuck paying too much attention to the first word, which limits how well they understand the rest. The authors studied different ways to fix this problem and found that changing the model’s goal during training, rather than its design, causes this issue. Techniques that seemed to reduce this problem at smaller scales did not work at the largest scales. This means that the behavior depends more on how models learn than on how they are built.
Open → 2609.08574v1

Probability transport improves on-policy knowledge transfer methods

Distillation as Probability Transport: Routed On-Policy Distillation

Abstract: On-policy distillation (OPD) transfers teacher knowledge on student-generated trajectories, but efficient sampled objectives reduce the teacher distribution to scalar credit on individual tokens. Such credit indicates whether a token should gain or lose probability, yet leaves the corresponding redistribution unspecified. We recast OPD as teacher-guided probability transport and propose RouteOPD (Routed On-Policy Distillation), which decomposes local teacher--student disagreement into student-excess sources and teacher-deficit destinations and couples them into explicit transport pairs. RouteOPD optimizes pairwise log-odds toward jointly realizable targets obtained from a bounded teacher potential, while adapting the transport budget to the concentration of teacher demand. This formulation directs updates toward teacher-preferred destinations and controls their magnitude within a single transport operator. Experiments across four teacher--student settings and four mathematical-reasoning benchmarks demonstrate that RouteOPD consistently outperforms sampled reverse-KL OPD, with improvements accompanied by higher routing fidelity and lower background leakage. These results demonstrate the effectiveness of explicitly modeling probability transport in on-policy distillation.

Tue 8 SeptMachine LearningComputation and Language
The gist
It can be hard for one AI model (the student) to learn from another (the teacher) because the usual methods only tell the student whether to increase or decrease the chance of choosing certain words, without explaining where that probability should move. The authors propose a new way called RouteOPD that treats this learning process like moving probability from places where the student guesses too much to places where the teacher thinks more focus is needed. This approach guides the student more precisely on how to adjust its probabilities, leading to better learning and performance on difficult reasoning tasks.
Open → 2609.08337v1

Multimodal retrieval improves answer accuracy with generator feedback

Bridging the Semantic-Utility Gap in Multimodal RAG via Generator-in-the-Loop Alignment

Abstract: Vision-language models (VLMs) augmented with retrieval-augmented generation (RAG) benefit from access to external evidence. However, standard retrievers and rerankers optimize for semantic similarity rather than answer utility, creating a preference gap: documents that appear relevant may not help the generator produce a correct answer. Motivated by this, we propose a two-stage generator-in-the-loop alignment framework that closes this gap without human document-level relevance annotations. Our framework consists of two stages: in Stage 1, a VLM generates a hypothetical text passage from the image-query pair, which is used as the retrieval query for dense text search, bridging the image-to-text modality gap. In Stage 2, a cross-encoder reranker adapted with low-rank adaptation (LoRA) is fine-tuned using answer-supervised preference pairs mined from the frozen VLM: given the dataset answer label, a candidate document is labeled positive if the VLM produces the correct answer when given that document as context, and negative otherwise. This generator-guided signal is compatible with multiple alignment loss functions, including contrastive (triplet) loss, pairwise direct preference optimization (DPO), and supervised fine-tuning (SFT), and supports periodic re-mining to refresh preference pairs as the reranker improves. Experiments on VQA-X and A-OKVQA with Qwen3.5-2B and Qwen3-VL-4B-Instruct show that our proposed framework consistently outperforms rank-order, random, and REPLUG-style likelihood baselines under various alignment losses and pool size settings, suggesting that answer-level generator feedback is an effective supervision signal for preference alignment.

Tue 8 SeptArtificial IntelligenceInformation Retrieval
The gist
One problem with vision-language AI models that search for information to answer questions is that they often pick documents that seem relevant but don’t actually help produce the right answer. The authors propose a two-step method where the AI first imagines a text description from an image and question, then uses that to find documents. Afterward, the model learns to pick documents based on whether they helped it produce correct answers in the past, without needing human judgments. Their experiments show that this technique consistently finds better documents and improves answer quality on standard tests.
Open → 2609.08188v1

European Portuguese web corpus expands with refined filtering methods

Fine PT-PT Web: A High-Quality 41 Billion Tokens Data Collection of the European Portuguese Web

Abstract: Curating Web corpora for regional language variants like European Portuguese (PT-PT) is heavily bottlenecked by dialectal overlap (mainly with PT-BR) and data processing scale. This paper presents an efficient pipeline to curate a production-ready PT-PT corpus from the Portuguese Web, spanning 411 TB of raw data from Arquivo.pt. We introduce a novel post-scraping block that removes boilerplate and line duplicates prior to filtering. This early-stage intervention increases final document yield by 19.04% by rescuing valid text that standard heuristic filters prematurely discard. Integrated with rigorous language identification, weighted fuzzy deduplication, and neural quality classification, our pipeline offers a scalable framework and a clean, representative corpus optimized for LLM pre-training.

Mon 7 SeptComputation and LanguageArtificial Intelligence
The gist
Collecting online text for specific language versions like European Portuguese is tough because it can get mixed up with Brazilian Portuguese and involves huge amounts of data. The authors created a smart process that cleans and sorts web data early to save more good content that usually gets thrown away. Their method also uses careful language checks, fuzzy duplicate removal, and AI-based quality checks to produce a clean and useful text collection. This collection can help train large language AI models specifically for European Portuguese.
Open → 2609.07699v1

Temperature modulation improves multimodal contrastive learning accuracy

TeMo: Temperature Modulation for Multimodal Contrastive Learning

Abstract: Contrastive learning approaches achieve strong performance by training models to bring similar samples closer while pushing dissimilar samples apart. A crucial component of contrastive learning is the temperature hyperparameter $τ$, which controls the penalty strength applied to negative samples. However, most existing methods either fix this hyperparameter or learn a global value during training. In this paper, we introduce TeMo, Temperature Modulation framework, a similarity-based modulation approach that adaptively adjusts the temperature for each positive-negative pair according to their similarity, enabling more fine-grained multimodal contrastive learning. Our approach seamlessly integrates temperature-modulated multimodal and unimodal losses with the standard multimodal contrastive loss by gradually transitioning between them. This design allows the model to capture both coarse- and fine-grained semantics at different training stages. Extensive experiments demonstrate that each component of TeMo consistently enhances performance across diverse zero-shot retrieval and classification tasks, establishing new state-of-the-art results.

Mon 7 SeptComputer Vision and Pattern Recognition
The gist
Contrastive learning helps computers tell apart things that are similar and different, using a setting called temperature to control how much difference matters. Most methods keep this temperature fixed or use one value for everything, but the authors introduce TeMo, which changes the temperature based on how similar each pair is. This lets the model learn more detailed relationships between different kinds of data, like images and text. Their experiments show that this approach improves performance on tasks like recognizing images without prior training examples.
Open → 2609.07540v1

Robot language skills improve with Greek added to bilingual training

Measuring Language Transfer in Robot Policies: Adding Greek to a Cosmos3 Vision-Language-Action Policy

Abstract: Robot foundation models are trained and evaluated predominantly in English, and robot demonstration corpora do not exist for most languages. We study the addition of Greek to an open vision-language-action stack using only machine-rephrased instructions and no architecture changes. The main challenge is measurement rather than translation. Several plausible instruments produce false conclusions: a color-histogram metric rewards noise, a single-goal benchmark scores 84.6% under correct Greek and 82.6% under deliberately wrong instructions, training loss fails to predict Greek success, and single-run comparisons are dominated by seed variation. On a discriminative ninety-task suite with three seeds per arm, a multilingual text tower without Greek demonstrations remains at its wrong-instruction floor, while Greek-only training exceeds its control by at most 2.7 points. Bilingual training yields a consistent 6.7-7.1 point margin over its control and reaches about two fifths of English performance. The policy also overfits the translator's phrasing; training on seven phrasings per task approximately halves this penalty. Warm-starting from a language-adapted world model and unfreezing the text tower both degrade performance. The results support two practical requirements for low-resource robot-policy localization: build a guaranteed null before trusting a metric, and replicate low-resource-language results across seeds.

Mon 7 SeptRoboticsArtificial Intelligence
The gist
Robots usually learn commands only in English because there aren't many training examples in other languages. The authors tried teaching a robot to understand Greek instructions using machine-translated commands without changing its design. They found it’s hard to measure if the robot really understands Greek, and some usual tests give wrong answers. Training with both English and Greek together helped the robot understand Greek better than just Greek alone, reaching about 40% of its English ability. They also found the robot learns specific ways of saying things too closely, but teaching it many ways to say the same command helps fix that.
Open → 2609.07470v1

Mathematical programming unifies many machine learning decisions

Mathematical Programming in Machine Learning and Artificial Intelligence: A Unified Taxonomy of Models and Applications

Abstract: Mathematical programming provides a common language for many decisions embedded in modern machine-learning (ML) and artificial-intelligence (AI) systems: selecting retrieval context, routing tokens, allocating inference compute, fitting structured predictors, protecting against distribution shift, and balancing competing objectives. However, the relevant literature is fragmented across optimization, information retrieval, recommendation, natural-language processing, computer vision, and learning theory. This paper organizes various applications under common mathematical programming paradigms: linear, quadratic, binary and mixed-integer, conic, bilevel, multi-objective, inverse, distributionally robust, submodular, and min--max optimization. We normalize the models with a mostly unified notation and, for every application, identify inputs, decision variables, a principal formulation, structural properties, solution strategies, and limitations. Across paradigms, we compare tractability, relaxation quality, decomposition, approximation guarantees, and scalability bottlenecks. The paper shows that mathematical programming is most useful not as a claim that all learning is LP or MIP, but as a disciplined interface between predictions and constrained decisions.

Mon 7 SeptArtificial Intelligence
The gist
Many decisions in AI and machine learning, like how to route data or balance goals, can be described using mathematical programs. The authors organize different models and applications in one common framework, showing how they compare and work. This helps clarify how math helps make decisions in AI systems, without oversimplifying them to just a few types of problems.
Open → 2609.07254v1

Language models struggle more with rare words but keep some grammar skills

FreqBLiMP: Frequency-Controlled Minimal Pairs Reveal Robustness and Fragility of LLMs Under Lexical Rarity

Abstract: Minimal-pair benchmarks such as BLiMP evaluate linguistic knowledge by testing whether language models (LMs) prefer acceptable sentences over minimally different unacceptable ones. However, these benchmarks largely ignore lexical frequency variation, despite lexical frequency being a pervasive and highly skewed property of natural language use. Consequently, existing evaluations do not test whether grammatical preferences remain stable when contrasts involve rare lexical items. We introduce FreqBLiMP, a frequency-controlled extension of BLiMP that regenerates all 67 paradigms under explicit Zipf-frequency regimes while preserving each minimal-pair's grammatical contrast. Evaluating multiple open-weight LLM families across scales, we find that decreasing lexical frequency produces a consistent, monotonic decrease in sentence likelihood, but only a modest reduction in overall contrastive acceptability accuracy. However, this aggregate stability masks substantial variation across linguistic phenomena, with LLMs remaining robust on overt morphosyntactic generalization while degrading on phenomena that require lemma-specific information.

Mon 7 SeptComputation and LanguageArtificial Intelligence
The gist
Language models are tested to see if they can tell good sentences from nearly identical bad ones. The authors found that when sentences have rare words, these models give them lower probabilities but still mostly pick the right grammar differences. However, the models do worse with grammar that depends on specific word knowledge and stay strong only on common grammar rules. This new test helps reveal where language models are sturdy and where they become fragile with unusual vocabulary.
Open → 2609.07153v1

Dynamic programming improves byte pair encoding vocabulary selection

Dynamic-Programming-Guided Hierarchical BPE and Empirical Analysis of Vocabulary Pruning

Abstract: Byte Pair Encoding (BPE) constructs vocabularies through greedy pair merging, but the resulting merge order does not necessarily allocate a fixed model-visible vocabulary optimally for compression. We propose Dynamic-Programming-Guided Hierarchical BPE (DH-BPE), a vocabulary-construction method that combines token exposure under exact minimum-token segmentation with the hierarchical dependencies induced by BPE training. Starting from a modestly overshot BPE candidate vocabulary, DH-BPE uses dynamic programming to measure candidate utility and applies exposure-guided, dependency-aware pruning to select a fixed-size model-visible vocabulary. We compare DH-BPE against Standard BPE and recent vocabulary-optimization baselines, including Pruned BPE, MinGram, and MinGram-PP, in primary evaluations at 12K and 16K target vocabulary sizes, with an additional 18K evaluation against MinGram only. Across the primary 12K and 16K comparisons, DH-BPE consistently improves aggregate compression over Standard BPE, Pruned BPE, and MinGram under a shared exact minimum-token DP encoder. MinGram-PP achieves stronger aggregate compression in the primary comparisons, but DH-BPE outperforms it at overshoot factors f = 2.0 and f = 3.0 in cross-corpus evaluation; at 12K, MinGram-PP reverses this ordering only with the substantially larger candidate pools at f = 4.0 and f = 5.0. Qualitative analysis further shows that DH-BPE balances later, more complete BPE merges with reusable subword components, providing a practical approach to improving vocabulary allocation under a fixed model-visible vocabulary budget.

Mon 7 SeptComputation and LanguageMachine Learning
The gist
When computers turn text into pieces to understand it better, they often use a method called Byte Pair Encoding (BPE). The order in which BPE chooses these pieces isn't always the best for compressing text efficiently. The authors came up with a new method, DH-BPE, that uses a smart planning technique called dynamic programming to pick a better set of pieces. Their tests show this method can compress text more efficiently than several existing methods, especially when carefully selecting how many pieces to consider at first.
Open → 2609.06898v1