Your paper timeline
Scroll AI takes the way you would scroll a great paper aggregator: quick signal first, deeper critique when something earns your attention, and challenges when a claim feels off.
1579 papers
Trending mixes fresh papers with community signal.
0
cs.LGstat.ML Junlin Chen, Wenhao Wang, Junchao Xu et al. · Oct 14, 2026

Class-incremental graph learning suffers from catastrophic forgetting because models are repeatedly fine-tuned on new classes, causing severe recency bias where earlier sessions are misclassified as recent ones. MAEM addresses this by freezing a dedicated Mixture-of-Experts expert per session and routing test nodes via the reconstruction error of session-specific masked autoencoders, eliminating the need for task identities or a shared trainable router. To prevent unbounded model growth, it merges least-used experts via Git Re-Basin alignment followed by topology-aware pseudo-data distillation, achieving strong replay-free performance across four benchmarks.

Graph Neural Networks (GNNs) excel on graph-structured data but suffer catastrophic forgetting when classes arrive sequentially. In class-incremental graph learning, predictions are often dominated by recently learned classes, causing severe recency bias. Dynamic expansion can isolate knowledge across sessions, but many methods assume task-incremental settings and require task identities at test time to select branches or heads---information unavailable in class-incremental learning. Learnable routers offer an alternative, yet continual fine-tuning the router on new data can bias routing toward recent components. We propose MAEM, a replay-free, capacity-controlled dynamic mixture-of-experts framework for class-incremental graph learning. MAEM builds representations with Simplified Graph Convolution (SGC) and trains a dedicated expert for each new session, then freezes it to protect prior knowledge. For routing without task IDs or a shared trainable router, each expert uses a masked autoencoder (MAE); test nodes are assigned to the expert with the lowest reconstruction error, reducing routing-level recency bias. When the expert pool reaches a fixed capacity, MAEM merges the least-used experts via Git Re-Basin alignment and further distills them into a fused expert using topology-aware pseudo data synthesized from MAE distributions (DeepInversion-style), without storing or revisiting historical graph data. On four class-incremental graph benchmarks, MAEM mitigates recency bias, outperforms strong continual graph learning baselines, and keeps model capacity bounded under strict replay-free learning.
0
stat.MLcs.LG Eliot Beyler, Francis Bach · Oct 14, 2026

Fine-tuning pretrained diffusion and flow matching models for reward maximization tends to collapse modes or shift mass between distant regions. This paper introduces Weighted Adjoint Matching, which modifies the stochastic optimal control formulation of Adjoint Matching by placing a time-dependent weight $w(t)$ on the quadratic control cost---expensive early to preserve coarse semantics, cheap late to refine details and increase reward. The authors prove equivalence to maximizing reward under pathwise KL regularization, and demonstrate improved reward-diversity tradeoffs on Gaussian mixtures and MNIST.

We introduce Weighted Adjoint Matching, a method to finetune a pretrained diffusion or flow matching model given a differentiable reward. We derive it from Adjoint Matching, which reformulates finetuning as a stochastic optimal control problem with a quadratic control cost. Building on the observation that these models generate coarse features before fine details, we place a time-dependent weight on the control cost. A high cost early in the generative process preserves balance and diversity in the coarse features, which carry most of the semantics, while a low cost at the end lets the model increase the reward by refining details. We prove that our method is equivalent to maximizing the reward under time-varying Kullback--Leibler regularization on the generative paths. Experiments on Gaussian mixtures and on MNIST show a better tradeoff between reward and mode balance than Adjoint Matching.
0
cs.LGcs.CV Alan Baade, Kyle Sargent, Vincent Sitzmann et al. · Oct 14, 2026

Training good latent tokenizers for generative models remains poorly understood, especially how to scale the encoder itself. This paper proposes Relative Prediction Representations (RePR), which supervise patch features to factorize a pointwise mutual information matrix estimated by a conditional diffusion model. The result is a theoretically grounded, negative-sample-free objective that resists feature suppression and claims to be the first to demonstrate compute-optimal tokenizer encoder scaling, matching or beating pixel-space diffusion at equal FLOPs.

We introduce an approach for self-supervised representation learning designed to be used as a tokenizer for generative modeling. Our objective supervises a representation loss by factorizing the pointwise mutual information of the data, which we estimate by taking information differences between conditional predictions from a learned generative model. We justify our algorithm theoretically and empirically, demonstrating that our generative approach to representation learning avoids dimensional collapse and feature suppression in cases where commonly used methods like DINO and LeJEPA fail. Moreover, we show our representation learning technique is scalable; expending more compute leads to predictably better latent tokenization. For the first time, we perform a careful analysis of the combined flop efficiency of tokenizer and generative model and demonstrate that our approach is a compute-optimal improvement over direct diffusion for pixel-space generation, obtaining an FID-50K of 2.18 with JiT-L. Applied to ImageNet and the text-to-image dataset GPIC, we show tokenizer encoder scaling laws for diffusability, where extrapolating our approach achieves representations in 7x fewer FLOPs than DINOv2 on ImageNet and 8x fewer FLOPs than WebSSL on GPIC.
0
cs.LG Lukas Niehaus, Robin Rawiel, Ulf Krumnack · Oct 14, 2026

KANLab is a browser-based educational tool that adapts the TensorFlow Playground interface to Kolmogorov-Arnold Networks (KANs). It strips away modern performance-oriented additions like residual connections and learnable scaling so that displayed B-spline curves map directly to their trainable control points, letting users drag points and watch gradient descent correct them in real time. By making KAN internals tangible in a compact 2D setting, it aims to bridge the gap between novices and experts.

KANLab is a browser-based visualization tool designed to interactively teach the core concepts of Kolmogorov-Arnold Networks (KAN), forked from the widely successful TensorFlow Playground. To maximize educational clarity, KANLab omits residual connections and learnable scaling parameters found in modern KAN implementations, ensuring that displayed B-spline activation curves directly correspond to their underlying trainable control points. Users can inspect and modify activation functions, initialization schemes and observe gradient descent correcting manual disruptions. Furthermore, user can explore phenomena such as activation variance, interactive pruning, and re\-/training within a compact 2D machine learning setting. KANLab is open-source and available at https://kanlab.app/
0
cs.LG Daman Arora, Xuecheng Liu, Himanshu Gaurav Singh et al. · Oct 14, 2026

Standard reinforcement learning on verifiable rewards incentivizes language models to guess rather than admit uncertainty, because a wrong answer carries no penalty while abstention foregoes any chance of reward. This paper frames graceful failure as a three-outcome RL problem (Success \succ Fallback \succ Error), identifies why naive policy-gradient methods collapse to degenerate always-fallback policies, and proposes GracefulRL, a log-barrier-shaped objective that preserves gradient signal near saturation. The idea matters because coding and agentic mistakes can propagate into real harm, yet current RL pipelines train models to maximize success rate without regard for how they behave when success is unlikely.

Reinforcement learning makes language models better at solving tasks, but the same mechanism also rewards guessing. When success is the only way to earn reward, opting for a safe fallback is always worse than a long-shot attempt. When a wrong action can corrupt a database or ship broken code, that incentive can be costly. Therefore, we propose training models to fail gracefully: to preserve successful behavior whenever possible while learning to execute a safe fallback policy when acting would be unreliable. However, naively using policy gradients with intermediate reward for fallback behavior is brittle due to unfavorable optimization dynamics. We address this challenge with GracefulRL, which reshapes the optimization landscape to promote graceful failure. Importantly, this behavior emerges directly from outcome-level reward signals, without annotations specifying when to fall back or additional inference-time machinery such as a verifier. Across a range of tasks and scales, we train models that largely preserve their task-solving capability while selectively falling back when acting would be unreliable. More broadly, our results show that reinforcement learning can not only incentivize models to succeed, but also to reason about the limits of their capabilities and change course when they determine that success is out of reach.
0
cs.LGstat.ML Renjie Xie, Juncheng Yang, Aoting Hu et al. · Oct 14, 2026

Mixed-precision quantization for sparse MoE models needs more than expert rankings: NatScale introduces contrast calibration, a principled way to control how strongly sensitivity scores compete for storage. It applies a model-specific power transformation $w_i = g_i^{\beta_\tau}$ so that normalized squared weights achieve a target Jeffreys divergence $\mathcal{J}(q(\beta_\tau), u) = \tau$, preserving rank order while setting a common information-theoretic scale. Combined with joint gate/up/down error measurement and spectral structural priors, it allocates bit-widths under a global byte budget via LP relaxation and rounding.

Mixture-of-experts (MoE) language models activate only a few experts per token, yet all expert weights must be stored. Mixed-precision quantization reduces this storage cost by assigning higher bit-widths to sensitive experts and lower bit-widths to resilient ones, but expert rankings alone do not determine how strongly to weight their errors. To address this gap, we propose NatScale, a contrast-calibrated allocation framework for mixed-precision MoE quantization. It uses a model-specific power transformation to calibrate gradient-based expert weights to an information-theoretic contrast target while preserving rankings. We jointly evaluate each expert's gate, up and down configurations to estimate its output error. We then combine these errors and calibrated weights with an existing prior based on weight spectra, variance and precision decay to select configurations under a storage budget. Across three models, NatScale achieves the lowest native-to-quantized KL divergence and the highest top-token agreement in all nine settings against five allocation baselines. It also yields the lowest perplexity in seven settings. These findings highlight the importance of objective-aware precision allocation.
0
stat.MLcs.LG BaoZhi Chu, Ben Weinkove · Oct 14, 2026

What is the least width required for a deep neural network to universally approximate continuous functions from $\mathbb{R}^n$ to $\mathbb{R}^m$? This paper attacks the minimal-width problem by importing tools from differential topology, proving that whenever real projective space $\mathbb{RP}^{n-1}$ smoothly immerses into $\mathbb{R}^n$, any network with a continuous monotone activation must have width at least $n+\min\{n,m\}$ to approximate arbitrary maps. This yields the exact ReLU minimal width $n+m$ for the special dimensions $n\in\{2,3,4,7,8\}$ with $m\le n$, and exposes a surprising link between universal approximation and the immersibility of projective spaces.

We investigate the minimal width of deep neural networks that can approximate all continuous functions from $\mathbb{R}^n$ to $\mathbb{R}^m$ in the topology of uniform convergence on compact subsets. We show that whenever the real projective space $\mathbb{RP}^{n-1}$ admits a smooth immersion into $\mathbb{R}^n$, the minimal width is at least $n+\min\{n,m\}$, assuming that the activation function is continuous and monotone. As a consequence, the minimal width of ReLU networks is $n+m$ whenever $n$ is equal to 2, 3, 4, 7 or 8 and $1\le m \le n$, extending results of Hanin-Sellke and Hwang. This suggests an intriguing connection between the approximation theory of neural networks and differential topology.
0
cs.LGstat.ML Dwaipayan Haldar, Indranil Patra, Azhar Yousuf et al. · Oct 14, 2026

Rotation-based post-training quantization for LLMs currently forces a choice between cheap data-agnostic transforms like Hadamard and costly learned rotations that require iterative optimization. SpectrumQuant introduces a closed-form, covariance-aware orthogonal transform derived from a first-principles objective on the Stiefel manifold: by aligning activations with their eigenbasis and applying a Hadamard or butterfly mixing component, it equalizes per-coordinate variances to minimize quantization error. The result is a method that cuts calibration costs by more than $20\times$ relative to learned baselines while preserving competitive accuracy on Llama and Mistral models.

Orthogonal transforms have emerged as an effective tool for low-bit quantization of large language models (LLMs), as they reshape activation distributions without changing the underlying model function. Existing approaches typically rely either on fixed data-agnostic transforms, such as Hadamard rotations, or on calibration-time optimization of learned rotations. We study rotation selection from first principles and show that maximizing covariance leads to spectral alignment and provides a principled criterion for constructing quantization-friendly orthogonal transforms. Based on this insight, we propose SpectrumQuant, a closed-form rotation method that estimates activation covariance from calibration data and uses it to construct a covariance-aware orthogonal transform for post-training quantization. Our formulation characterizes quantization-friendly rotations as compositions of alignment and mixing components, while recovering Hadamard matrices as a special case. Interestingly, a class of butterfly matrices belongs to this category. In the realm of LLM quantization, SpectrumQuant bridges the gap between data-agnostic structured rotations and learned rotations, providing an effective and efficient data-aware alternative for post-training quantization. Experiments on Llama and Mistral models show that SpectrumQuant is competitive with state-of-the-art rotation strategies while requiring less than one-third of the GPU memory and significantly less time than learned rotations approaches like SpinQuant and DartQuant.
0
cs.LG Hanyao Guo, Mo Cui, Zihan Tan et al. · Oct 14, 2026

ChemArgus tackles a real blind spot in chemistry evaluation: endpoint-only scores hide where reasoning chains break. The benchmark enforces fine-grained rubric scoring across three controlled protocols that share a single scoring unit, so gaps between full-problem, sequential-carry, and oracle-scaffolded results isolate integration, propagation, and local-reasoning failures. The design is principled, yet the paper never states the dataset size and evaluates models lacking citations or independently verifiable endpoints, leaving the empirical results impossible to validate.

Chemistry evaluation has moved past multiple-choice probes toward open-ended expert problems, yet the benchmarks that define the current frontier still score answer endpoints alone. Such scoring conflates memorized facts with stepwise derivation, treats visual and textual inputs as interchangeable, and confounds long-horizon planning with stepwise execution. These blind spots prevent any diagnosis of where the reasoning chain breaks in a model. We present ChemArgus, a competition-level chemistry benchmark drawn from chemistry competition material, textbooks, and research papers, whose scoring replaces the answer endpoint with three measurement properties. Fine-grained scoring grades every subquestion point by point with partial credit, so a score lands at the level of the step rather than the outcome. Multimodal capability is priced on every problem containing a real image, paired with a controlled text description, so visual understanding is measured against text on identical tasks. Diagnostic attribution reads paired metrics that share one scoring unit and differ only in context construction, so a gap between two scores isolates a single cause, namely integration, propagation, or local reasoning. GPT-5.6-Sol scores 23.2% on unassisted whole-problem solving against 28.8% and 30.4% under the two sequential metrics, a gap measuring the integration burden. Through rubric partial credit and these cause-isolating score gaps, ChemArgus shows not only whether a model answers chemistry correctly but where its reasoning chain fails, so that every score it reports doubles as a diagnosis, a readout of the chain rather than a verdict, aiming to guide language models step by step on their path toward chemistry expertise, one corrected step at a time, each step priced by the rubric, point by point.
0
cs.DCcs.LG Daijin Hu · Oct 14, 2026

JointServe targets multi-model LLM agent serving on memory-constrained GPUs, where heterogeneous expert weights and ever-growing KV caches physically contend for HBM bytes. It unifies weight shards and KV blocks as competing residency objects under one budget, exploits the agent's own tool-call stream to prefetch destination experts during caller generation gaps, and streams only incremental layer groups when a swap occurs. The work is motivated by the architectural shift from single-model tool use to planner-orchestrated pools of heterogeneous experts—a pattern visible in SWE-bench, $\tau$-bench, and OSWorld traces—and targets the private and edge deployments where full co-residency is arithmetic impossible.

LLM agents are evolving from a single model calling tools to planners that orchestrate multiple expert models whose capabilities live in distinct weights. This shift breaks a hidden assumption of today's serving systems: that the working set of models fits in GPU memory. On the memory-constrained GPUs typical of private and edge deployments, naive whole-model swapping serializes weight transfer with computation and, without host-backed KV restoration, discards session state at a switch. We present JointServe, a serving system that treats weight shards and KV blocks as residency objects competing for one unified memory budget. JointServe exploits three structural properties of agent workloads (directed calls, gapped execution, and dual-state residency) to prepare models before they are called: an intent signal parsed from the caller's own output stream triggers prefetch during generation, partial k* residency reduces switching to incremental layers, and a preemptive transfer scheduler protects live-session KV with a guaranteed bandwidth share. A carve-out control step adjusts the weight/KV allocation as workload demands change. Evaluations show that JointServe reduces session completion time by 21.7% over the strongest whole-model swap baseline and stays usable in a crash regime where every whole-model swap baseline fails to finish (a 46-fold gap). On replayed SWE-bench, tau-bench, and OSWorld traces, it cuts session completion time by up to 49% and lifts SLO attainment from 2.8-24.5% to 76.8-100%.
0
cs.LGcs.SYeess.SY Luka Todorovic, Kaushal Gianchandani, Sai Ravela · Oct 14, 2026

Neural emulation need not require learning a substitute for known physics. This paper investigates PolyNets that compile continuous-time polynomial dynamics and discrete-time RK4 integration into a single tensor graph, benchmarking the approach on the 1D Korteweg–de Vries equation against classical CPU/GPU solvers and three trained neural models. The central finding is that when governing coefficients are known, the resulting network requires no training yet preserves numerical fidelity while achieving competitive GPU throughput.

Neural emulation need not require learning a substitute for known physics. We investigate PolyNets that couple a continuous-time neural representation of polynomial dynamics with a simple recurrent network for discrete-time integration. When the governing coefficients are known, the resulting tensor graph requires no training and preserves the prescribed numerical scheme while enabling efficient hardware execution and parallel simulation. Using the one-dimensional Korteweg-de Vries equation, we compare PolyNet with CPU and GPU finite-difference Runge-Kutta solvers and three trained neural models: a state-map emulator, a physics-informed predictor, and a learned-tendency integrator. Analytical soliton solutions provide a reference for amplitude and phase errors across grid resolutions, 10^6 dispersively scaled time steps, ensembles of up to 10^4 trajectories, and varying initial amplitudes. PolyNet achieves accuracy comparable to the numerical solvers, including at amplitudes outside the learned models' training conditions. It combines this fidelity with high GPU throughput, approximately constant over the tested resolution range, and favorable ensemble scaling.
0
cs.SEcs.LG Rakhshanda Jabeen, Morgan Ericsson, Jonas Nordqvist et al. · Oct 14, 2026

Architectural drift is expensive to detect when the mapping between source files and architectural modules is missing or outdated. This paper frames code-to-architecture mapping as semi-supervised node classification over a directed multi-relational dependency graph, expanding a small labeled seed via iterative self-training. By holding features, training loops, and classifier heads fixed across GCN, GAT, and a graph-free MLP, the authors isolate whether dependency structure genuinely improves mapping accuracy.

Architectural technical debt arises when a system's implementation drifts from its inten ded modular decomposition, while the mapping between source files and architectural modu les is missing, incomplete, or costly to maintain manually. We formulate code-to-archite cture mapping as semi-supervised node classification over a directed multi-relational de pendency graph, with files as nodes, typed dependencies as edges, and lexical features d erived from code identifiers and directory layout. Starting from a small labeled sample, an iterative self-training procedure expands the mapping to the remaining files. We com pare a graph convolutional network (GCN), a graph attention network (GAT), and a graph-f ree multi-layer perceptron (MLP), using identical features and training procedures for t he learned models, against a Naive Bayes reference. Across 100 runs on ten open-source J ava and C/C++ systems, all three neural models outperform the reference on both F1 metri cs. GAT achieves the highest averages of system-level median macro and micro F1, at 83.5 and 92.2, respectively, whereas MLP remains competitive or superior on several systems. On Chrome, the largest system with 18,343 files, GAT and GCN exceed MLP by 22 and 19 ma cro-F1 points, respectively, and have substantially fewer persistently misclassified fil es. Connectivity and homophily are associated with where neural message passing helps, w hile multi-relational aggregation outperforms a single merged edge type on every system for both GCN and GAT. A follow-up study finds that several model rankings depend on the training seed, qualifying smaller advantages without removing the large graph benefit ob served on Chrome.
0
cs.CLcs.LG Junyi Zou, Avrova Donz · Oct 14, 2026

MMLA-RSI proposes recursive self-improvement through two Memory-Mediated Learning Architecture routes: Reasoning-Time Training (RTT) treats the numerical policy-state updater as an object of improvement, while Reasoning-Time Memory Adaptation (RTMA) treats the memory-management rule as an object of improvement. Each admitted successor takes over its parent's role in producing the next generation's rule. The paper's main contribution is a formally bounded construction with shared interfaces and a common algorithm, though the authors explicitly state that beneficial recursive chains remain to be evaluated.

An agent can improve its behavior within an unresolved problem by changing how it acts and which experience it retains. We propose MMLA-RSI, a recursive self-improvement scheme with two implementations in Memory-Mediated Learning Architecture: Reasoning-Time Training (RTT) changes the policy state $\Phi$, while Reasoning-Time Memory Adaptation (RTMA) changes authoritative memory $M$. Each route also makes its adaptation method an object of improvement. A current numerical updater trains the policy proposing its successor; a current memory manager chooses the records available to the process proposing its successor. An independently admitted successor takes over the same role in the next generation. We give bounded executable rule languages, shared task/proposal interfaces, and one algorithm for either route or their composition. The RTT instance changes scalar schedules in a clipped-momentum update. The RTMA instance chooses NULL or a complete-row write with possible eviction. A fixed interpreter, trusted committer, and independent evaluator bound what can change. State versions, read closures, and conditional properties describe causal execution, accepted transitions, and finite work. Existing numerical-component studies motivate the construction. In four-candidate program selection, retaining LARC feedback updates reduces expected error by 24.65 and 36.65 percentage points for two trained initializations. In chronological continuous-integration replay, feedback binding is positive while retention increases loss. Completed SQL studies improve substantially over an unadapted substrate but do not establish the required additional online benefit. These results characterize their declared components. The two recursive routes and their joint realization are specified here; their beneficial recursive chains and discovery efficiency remain to be evaluated.
0
cs.LG Jincheng Gao, Jiahe Yi, Shuo Sun · Oct 14, 2026

MorphingNet attacks the scalability problem in symbolic regression by turning formula search into continuous network training. Its units are pole-free rational functions and complex exponential-logarithm shapes whose parameters morph smoothly between elementary forms, so the network itself is a closed-form formula at every step. A post-training structure-recovery step rewrites the learned expression into compact elementary notation. The paper reports state-of-the-art SRBench accuracy, exact recovery of most ground-truth formulas, and GPU speedups of two orders of magnitude over genetic programming on large data.

We introduce MorphingNet, a network for symbolic regression (SR) whose units change their function continuously. Instead of searching over expressions built from a fixed operator library, MorphingNet trains the form of each function as a parameter, so SR becomes one continuous optimization problem. Its units are either pole-free rational functions or complex exponential--logarithm functions, which move between exponentials, sinusoids, damped oscillations, power laws and logarithms as their parameters change. The network is a readable formula at every step of training, and no operator library is needed to train it; a structure-recovery step afterwards rewrites the trained formula into short elementary expressions. Training is dense linear algebra, so it is GPU-friendly and scales to large data. MorphingNet achieves state-of-the-art accuracy on SRBench, recovers most generating formulas on synthetic benchmarks, and on large data is up to two orders of magnitude faster than the strongest search method. By turning the search for a formula into the training of a network, MorphingNet offers a new paradigm for SR and for scientific discovery from data.
0
cs.LG Chengyi Pan, Huangqimei Zheng, Hao Xue · Oct 14, 2026

CTIA-ODE proposes a continuous-time architecture for long-term multivariate forecasting that sidesteps rigid alignment between endogenous and exogenous variables. Its core mechanism, Continuous-Time Inter-Variable Attention (CTIA), lets a Neural ODE’s evolving hidden state query a static exogenous key-value field during integration. The framework is stabilized by a Linear Residual Augmentation trend anchor and an Outlier-Robust Hybrid Loss. The authors report state-of-the-art results across eight benchmarks with a compact memory footprint.

Although multivariate time series forecasting has broad application prospects, effectively incorporating exogenous variables remains challenging. Prevailing discrete-time architectures often impose rigid temporal alignment across heterogeneous variables, which may limit their ability to capture continuously evolving external effects. To address this limitation, we introduce CTIA-ODE, a continuous-time forecasting framework centered on Continuous-Time Inter-Variable Attention (CTIA). Specifically, CTIA is embedded within an ordinary differential equation (ODE) solver, enabling the continuously evolving endogenous trajectory to dynamically query a static exogenous context along the integration path without requiring explicit temporal alignment. To improve the stability of the continuous latent dynamics, we further introduce a dual-stabilization strategy: architecturally, a Linear Residual Augmentation (LRA) module provides a macroscopic trend anchor, while an Outlier-Robust Hybrid Loss (ORHL) mitigates the influence of heavy-tailed anomalies during optimization. Extensive experiments across eight real-world datasets demonstrate that CTIA-ODE achieves state-of-the-art forecasting performance across diverse datasets and prediction horizons, while maintaining a favorable accuracy-efficiency trade-off with a compact memory footprint and low inference latency, particularly under long-horizon forecasting settings. Anonymous code is available at https://anonymous.4open.science/r/CTIA-ODE-15A6/.
0
cs.CVcs.LG Junhoo Lee, Hyeonjin Kim, Sangbum Han et al. · Oct 14, 2026

Discriminative models generalize to unseen samples, suggesting they capture data-manifold structure beyond their task labels. This paper asks whether that structure can be exposed as a generative signal without retraining, labels, or auxiliary generators. The authors propose the Discriminative Score Function (DSF), which turns the loss-gradient geometry of a fixed discriminative model into an image-space update rule. DSF enables unconditional generation, conditional guidance, inpainting, and zero-shot quantization calibration across classifiers, detectors, and self-supervised encoders.

Discriminative models are trained with task-specific objectives such as classification, detection, or representation learning, yet their practical utility depends on generalizing beyond the training task to unseen samples from the same domain. This suggests that a discriminative model may retain an implicit trace of the data manifold beyond its task labels. We ask whether this trace can be exposed as a generative signal without task-specific guidance. We introduce the Discriminative Score Function (DSF), which extracts an image-space generative field from the loss-gradient geometry of a pretrained discriminative model. DSF provides a training-free update rule that moves images toward model-consistent visual regions without retraining or task-specific targets. We apply DSF to diverse pretrained discriminative models, including ResNet classifiers, DETR detectors, and DINOv2 ViT encoders. DSF generates unconditional images from noise and supports conditional guidance, editing, inpainting, and explanation through the same field. DSF-generated samples also provide effective zero-shot quantization calibration when real images or labels are unavailable, preserving feature geometry better than data-free calibration baselines. These results show that discriminative training leaves a generative functional signal for synthesis and calibration. Project page: https://junhoo.me/dsf.
0
stat.MLcs.LGstat.CO Thibaut Pellerin, Alain Durmus, Elinor Berger et al. · Oct 14, 2026

Standard diffusion models rely on additive Gaussian noise, yet many imaging modalities---including PET and astronomical photon counting---produce discrete Poisson observations. This paper introduces Mixed Poisson Diffusion Models (MPDMs), a generative framework in which the forward corruption is driven by multivariate counting processes rather than Brownian motion. The core payoff is a family of posterior samplers structurally matched to Poisson inverse problems, featuring exact sampling for Poisson denoising and principled adaptations of DPS, PnP-DM, and DAPS.

Diffusion models are a powerful framework for learning complex probability distributions. While widely used diffusion models for continuous data rely on Gaussian noising processes, we instead develop diffusion models based on Poisson noise. More precisely, we introduce and study a new mathematical framework, called Mixed Poisson Diffusion Models (MPDM), with noising dynamics driven by multivariate counting processes. Our methodology is motivated by Poisson inverse problems. The success of Gaussian diffusion models has led to their use as prior models in a growing number of posterior sampling methods for inverse problems. However, most of these approaches focus on Gaussian inverse problems, in which observations are generated through a deterministic forward operator corrupted by additive Gaussian noise. By contrast, Poisson inverse problems, where observations are discrete and Poisson distributed, remain comparatively underexplored in this literature. Building on our Poisson generative dynamics, we develop a natural framework for posterior sampling in Poisson inverse problems and derive several posterior sampling algorithms based on the proposed model. We evaluate our approach on realistic Poisson inverse problems and show that the resulting framework is well suited to this class of problems.
0
cs.LG Yaozhi Wen, Kun Zhao, Wei Wei et al. · Oct 14, 2026

NeuroDETR tackles asynchronous EEG event detection, where the goal is to identify both the class and temporal boundaries of neural events directly from continuous recordings without predefined windows. The method introduces a DETR-style architecture that uses multiscale discrete spatiotemporal vector quantization to build compact event memories, combined with an event-aware sparse attention module called FOCAL that concentrates refinement on likely event periods. Evaluated across eight diverse EEG datasets spanning P300, motor imagery, speech, and seizure detection, the authors report state-of-the-art event-level F1 scores compared to five baselines.

Asynchronous EEG event detection supports practical brain-computer interfaces by identifying event classes and temporal boundaries directly from continuous recordings without predefined event boundaries at inference time. The primary challenge lies in extracting event-related patterns embedded in ongoing background activity. To address this, we propose \textbf{NeuroDETR}, a discrete spatiotemporal multiscale framework that combines structured tokenization with event-aware feature refinement. Multiscale temporal codebooks capture brief responses and sustained dynamics, while Spatial-Pyramid VQ hierarchically encodes spatial structure across EEG channels. These complementary representations form a compact event memory for jointly classifying events and estimating their onsets and offsets. Before tokenization, we apply FOCAL, an event-aware sparse attention module that uses predicted event presence to guide temporal feature refinement and spatial aggregation, emphasizing likely event periods while preserving context across the recording. Experiments on eight EEG datasets that span diverse paradigms demonstrate state-of-the-art performance. These findings provide a basis for the development of BCI systems that recognize meaningful neural activity during continuous interaction and monitoring.
0
cs.CLcs.LG Linhao Zhong, Bozhen Fang, Xuehao Wang et al. · Oct 14, 2026

This paper confronts the evaluation crisis in agentic self-distillation, where a flood of recent methods claim gains over GRPO using inconsistent protocols and reused baselines. The authors conduct a unified benchmark of ten representative approaches across four tasks, three model sizes, and 132 training runs totaling over 12,000 H800 GPU-hours, measuring not only final accuracy but also training stability and wall-clock cost. Their central finding is sobering: no method consistently beats GRPO, many suffer severe hidden instability, and extra compute rarely translates into better agents.

Self-distillation in agentic reinforcement learning has produced a growing number of methods. However, existing evaluations often reuse published baseline scores under differing experimental conditions, provide few direct comparisons among contemporaneous methods, and give limited attention to training stability and computational cost. These limitations obscure the source of reported gains and the practical strengths and weaknesses of competing methods. Costly agent training further motivates a common basis for comparison. To address these gaps, we compare ten representative methods against GRPO on ALFWorld, ScienceWorld, Search-QA, and WebShop across three model sizes. Our study comprises 132 training runs totaling 12,124.4 recorded H800 GPU-hours, with repeated evaluations over eight rollout seeds for the pretrained backbones and all eleven trained methods. Beyond final task performance, we examine training progress, stability, and measured computational cost. Our evaluation yields three key findings. First, gains over GRPO remain limited in scope, with no method consistently outperforming it across settings. Second, strong final performance can mask unstable training. Third, additional training cost does not consistently translate into better performance. We establish this benchmark to support fair, comprehensive comparison and guide future research toward reliable and cost-effective improvements in agent training. Project page: https://aim-uofa.github.io/Self-Distillation-AgentRL/
0
eess.SPcs.LG Mohamed Kamel, Tamer Nadeem · Oct 14, 2026

Single-channel RF receivers cannot use spatial filtering when a desired signal overlaps with a structured co-channel interferer in both time and frequency, a regime where linear filters fail because the impairment is non-Gaussian. FlowSep-RF addresses this by learning a clean-endpoint rectified flow that maps a raw IQ mixture directly to the target waveform, enabling separation with a single neural function evaluation instead of iterative diffusion sampling. The core idea is to treat the received mixture as the source and the clean signal as the target of a near-straight flow, combining time-domain and frequency-domain features to improve reconstruction fidelity and downstream demodulation accuracy. If the gains hold under broader channel conditions, this could provide a low-latency replacement for score-based separators in practical baseband receivers.

Single-channel radio-frequency (RF) signal separation is important for interference mitigation when a signal of interest overlaps with a co-channel interferer in time and frequency. Classical matched filtering and LMMSE receivers are limited under structured non-Gaussian interference, while diffusion and score-based methods often require iterative sampling or optimization. We propose FlowSep-RF, a rectified flow matching framework that learns a clean-endpoint transport from the received mixture to the signal of interest. The model combines time-domain IQ samples with frequency-domain features and recovers the separated waveform using one endpoint velocity evaluation. We evaluate FlowSep-RF on QPSK mixtures with OFDM-BPSK, OFDM-QPSK, and RFChallenge CommSignal2 interference against classical, discriminative, and generative baselines. FlowSep-RF achieves the lowest average BER and MSE among evaluated baselines across all three settings with one-step inference.