arxiv_id
stringlengths
10
10
title
stringlengths
6
152
authors
listlengths
1
35
presentation
stringclasses
3 values
track
stringclasses
6 values
difficulty
stringclasses
2 values
background
stringlengths
400
914
method
stringlengths
744
2.2k
claim
stringlengths
168
603
claim_source
stringlengths
15
192
metric
stringlengths
57
852
comparison
stringlengths
63
533
falsification_criterion
stringlengths
112
492
image
imagewidth (px)
300
1.95k
image_kind
stringclasses
2 values
caption
stringlengths
24
1.35k
arxiv_url
stringlengths
32
32
openreview_url
stringlengths
0
42
on_papers_with_code
bool
1 class
papers_with_code_url
stringlengths
42
42
2110.01950
Classification of high-dimensional data with spiked covariance matrix structure
[ "Yin-Jen Chen", "Minh Tang" ]
poster
journal:TMLR
harder
Fisher's linear discriminant rule is Bayes-optimal for two Gaussian classes with a shared covariance, but its plug-in version can do no better than random guessing when the number of features p is comparable to or larger than the sample size n. Most high-dimensional fixes assume the discriminant direction β = Σ⁻¹(µ2 − ...
lda∘pca (Algorithm 1) estimates the whitening matrix W = Σ^{-1/2} under a spiked model Σ = UΛUᵀ + σ²I. The top d eigenpairs (Û, Λ̂) of the pooled sample covariance are kept, σ̂² is set to (tr Σ̂ − tr Λ̂)/(p − d), and Ŵ = Û(Λ̂ + σ̂²I)^{-1/2}Ûᵀ + σ̂⁻¹(I − ÛÛᵀ). The method whitens the class means, keeps the s largest coor...
In the equal-correlation simulation (p = 800, 100 training points per class, ρ = 0.5), lda∘pca has a test mis-classification rate of 1.74% (sd 1.00) against 3.27% (sd 1.47) for DSDA, the best non-oracle baseline. The Bayes error is 1.37%. lda∘pca uses about 12 whitened features, while DSDA uses about 96 raw features.
Table 1, page 13 (feature counts from Table 2, page 14)
Test mis-classification rate (%), lower is better. Mean over 200 Monte Carlo replicates; the value in parentheses is the standard deviation across replicates, not a standard error.
lda∘pca vs. DSDA (strongest baseline at ρ = 0.5), AdaLDA, CAT-LDA, DSDA(rot), AdaLDA(rot), SLDA, NSC, and the oracle Bayes rule
Over 200 replicates of Model 1 with ρ = 0.5, the mean error of lda∘pca is not below DSDA's (or AdaLDA's), or the gap is smaller than one per-replicate standard deviation (about 1.0–1.5 points).
table
Table 1: Mis-classification rate (%) with standard deviations (%) in parentheses for equal correlation setting (model 1), based on 200 independent Monte Carlo replicates.
https://arxiv.org/abs/2110.01950
true
https://paperswithcode.co/paper/2110.01950
2410.13735
Generative Conformal Prediction with Optimized Coverage Allocation
[ "Minxing Zheng", "Shixiang Zhu" ]
poster
main
standard
Split conformal prediction wraps any predictive model to give prediction sets with guaranteed marginal coverage (e.g. 90%), but the sets are often much larger than necessary when the conditional distribution p(Y | X) is multimodal or heavy-tailed. One line of work uses generative models: Probabilistic Conformal Predict...
ORCA (Optimized Ranking and Coverage Allocation) draws K conditional samples per input from a fitted generative model (here a quantile regression forest for 1-D responses; K = 20, m = ceil(sqrt(K))) and ranks them by their average m-nearest-neighbor distance among the samples (a local density proxy). On an exploration ...
At alpha = 0.1 with all methods at ~0.90 marginal coverage, ORCA's mean prediction-set size is 3.61 ± 1.27 on Blog, 3.70 ± 1.75 on Fb1 and 5.68 ± 1.62 on Fb2, versus 8.27 ± 0.21, 7.79 ± 0.28 and 9.35 ± 0.21 for the best baseline (PCP), roughly a 39-56% reduction.
Table 3 (Appendix F.2), page 22; summarized in Figure 4, page 9
Eff = average Lebesgue measure (interval length) of the prediction set on 1,000 test points (lower is better), subject to marginal coverage near 0.90; ± is standard error over 30 runs
ORCA vs. CQR, CHR, DCP-CQR, DistSplit, CDSplit, CRD, R2CCP and PCP under the same data splits, alpha and (mostly) the same QRF base model; PCP is the strongest baseline on these three datasets
On Blog, Fb1 or Fb2, ORCA's mean set size at ~0.90 test coverage is not clearly smaller than PCP's (difference within the reported standard errors), or ORCA reaches the smaller size only with marginal coverage below ~0.89.
table
Table 3: Summary of real data results. Metrics include marginal coverage (Cover), worst-slab conditional coverage (Cond_Cover), and prediction set efficiency (Eff). Values report mean ± standard error over 30 runs. The lowest efficiency per dataset is bolded and highlighted along with corresponding coverage metrics.
https://arxiv.org/abs/2410.13735
https://openreview.net/forum?id=lgTafhvFUa
true
https://paperswithcode.co/paper/2410.13735
2410.22559
Disentanglement as Identifiable Pushforward Factorisation
[ "Carl Allen" ]
poster
main
harder
VAEs and β-VAEs often learn disentangled representations, where changing a single latent coordinate changes a single generative factor of the data, even though nothing in the objective explicitly asks for it. A common hypothesis is that the diagonal Gaussian posterior covariance, chosen for computational convenience, p...
Gaussian VAEs with latent dimension d = 10 are trained on dSprites (5 known generative factors) with either diagonal or full posterior covariances, for β ∈ {0.001, 0.01, 0.1, 1}; results are averaged over 5 runs. Disentanglement is measured from the mutual-information matrix between each latent coordinate and each grou...
On dSprites with d = 10 Gaussian VAEs, diagonal-posterior models become more disentangled as β rises from 0.001 to 1 (MIG about 0.05 → 0.40, AAS about 0.41 → 0.87), whereas full-posterior models do not (MIG stays about 0.06-0.11; AAS falls from about 0.50 to about 0.02), so at β = 1 diagonal posteriors give MIG about 0...
Figure 6 (left and centre panels), page 7
MIG and AAS (higher = more disentangled), computed from latent-factor mutual information; lines are means over 5 runs with shaded bands whose definition is not stated; values are read off the plot and approximate
Diagonal-posterior vs. full-posterior Gaussian VAEs on dSprites, same d = 10, at β ∈ {0.001, 0.01, 0.1, 1}
Retraining both VAE variants on dSprites (d = 10, several seeds), diagonal-posterior MIG at β = 1 is not clearly higher than full-posterior MIG (e.g. gap under ~0.15 or overlapping seed spread), or diagonal-posterior MIG/AAS do not increase from β = 0.001 to β = 1.
figure
Figure 6. Diagonal vs Full Posteriors: (left) (bottom) disentanglement metrics and estimated diagonality of Eq. 8 terms (see Appendix F). With diagonal posteriors, disentanglement and diagonality are correlated (supporting P1), relative to full posteriors; (top) heatmaps of mutual information between model latents and ...
https://arxiv.org/abs/2410.22559
https://openreview.net/forum?id=3Kq1axaXfK
true
https://paperswithcode.co/paper/2410.22559
2412.09498
Gradient descent inference in empirical risk minimization
[ "Qiyang Han", "Xiaocong Xu" ]
poster
journal:AoS
harder
Gradient descent is the standard way to fit empirical risk minimization models, but when the sample size m and the dimension n are proportional (the mean-field regime), the gradient descent iterates are biased and depend on one another in ways classical theory does not describe. Valid confidence intervals for individua...
The authors derive a non-asymptotic state evolution for the gradient descent iterates mu^(t) in models Y_i = F(<A_i, mu*>, xi_i). The theory says that the debiased iterate mu_db^(t) = mu^(t-1) + eta * sum_{s in [1:t]} omega_{t,s} A^T d1L(A mu^(s-1), Y), with omega^[t] = (tau^[t])^{-1} the inverse of an 'Onsager correct...
In linear regression with m = 1200, n = 1000 and no regularization, the 95% CIs built from the debiased gradient descent iterate via Algorithm 1 have median coordinatewise coverage of about 0.95 (repetition boxes roughly 0.94-0.96) at every iteration t = 10, 20, 30, 40, 50, for both squared loss and pseudo-Huber loss w...
Figure 1 (middle column), page 28
Empirical coverage of nominal 95% CIs averaged over the n = 1000 coordinates (target 0.95); box plots show the spread over B = 1000 Monte Carlo repetitions. No other error bars.
Empirical coverage of the debiased-GD CIs vs. the nominal 95% level, across iterations, two losses and three design distributions. There is no competing inference method in the figure.
Following the paper's setup, the median coverage at some iteration in {10, ..., 50} falls clearly outside about [0.93, 0.97] (e.g. below 0.92) for either loss or any of the three designs, or the standardized debiased coordinate (mu_db;1 - mu*_1)/sigma_db departs clearly from N(0,1) in a QQ plot.
figure
Figure 1. Linear regression. Top row: Squared loss. Bottom row: Pseudo-Huber loss.
https://arxiv.org/abs/2412.09498
true
https://paperswithcode.co/paper/2412.09498
2501.04052
RaZeR: Pushing the Limits of NVFP4 Quantization with Redundant Zero Remapping
[ "Yuzong Chen", "Xilai Dai", "Jake Hyun", "Chi-Chih Chang", "Wonsuk Jang", "Yuheng Wu", "Thierry Tambe", "Jae-sun Seo", "Mohamed Abdelfattah" ]
poster
main
standard
NVFP4 is the 4-bit format that NVIDIA Blackwell GPUs support natively for LLM inference: each block of 16 values is stored as FP4-E2M1 elements (±{0, 0.5, 1, 1.5, 2, 3, 4, 6}) sharing one FP8-E4M3 scale, plus a per-tensor FP32 scale. The format wastes some of its bits. FP4 has both +0 and -0, so one of its 16 codes is ...
RaZeR remaps the redundant FP4 negative-zero code to a per-block 'special value'. For weights, the block scale is stored as E3M3 instead of E4M3 (Table 1 shows no perplexity loss from this), which frees 2 bits per block when combined with the unused sign bit. Those 2 bits select one of 4 allowed special values for that...
With weight-only 4-bit quantization (W4A16, block size 16), RaZeR gives lower perplexity than native NVFP4 on Llama-3.1-8B (WikiText-2 6.50 vs 6.63; C4 9.29 vs 9.48; FP16 6.24 / 8.96) and Llama-3.2-3B (WikiText-2 8.10 vs 8.24; C4 10.86 vs 11.10). In all four cases it also beats FourOverSix (6.60 / 9.42 / 8.21 / 11.05).
Table 3, page 6
Perplexity on WikiText-2 and C4 (2K context), lower is better; single deterministic runs, no ± reported
RaZeR (FP4 + per-block special value from {±5, ±8}, E3M3 block scale) vs. native NVFP4 (FP4, E4M3 block scale) and FourOverSix (4over6), all at block size 16 and 4.5 effective bits, weight-only quantization of Llama-3.1-8B and Llama-3.2-3B
Using the same block size, special values and evaluation protocol, RaZeR's perplexity on Llama-3.1-8B or Llama-3.2-3B (WikiText-2 or C4) is not lower than NVFP4's, or it closes less than about half of the reported NVFP4-to-RaZeR gap (for example, Llama-3.1-8B WikiText-2 RaZeR ≥ 6.57 when NVFP4 reproduces at about 6.63)...
table
Table 3. Perplexity (↓) under different 4-bit weight-only and weight-activation quantization methods. KV-cache remains in FP16.
https://arxiv.org/abs/2501.04052
https://openreview.net/forum?id=pnWgnXoHMP
true
https://paperswithcode.co/paper/2501.04052
2501.04794
A Steerable Deep Network for Model-Free Diffusion MRI Registration
[ "Gianfranco Cortés", "Xiaoda Qu", "Baba C Vemuri" ]
poster
main
harder
Nonrigid registration aligns one brain scan to another and is needed for cross-subject comparison and atlas building. Diffusion MRI (dMRI) is harder to register than structural MRI because each voxel stores direction-dependent diffusion measurements, which have to be reoriented when the image is warped. Existing deep-l...
The raw dMRI signal on each q-space shell is treated as a function on position-and-orientation space (R^3 x S^2), and registration is posed as finding an SE(3)-equivariant diffeomorphism of that space (the 'diff-pq' problem), so no explicit Jacobian reorientation is needed. A VoxelMorph-style UNet (encoder depth 3) bui...
On HCP test registrations to a single fixed subject, the raw-dMRI SE(3)-equivariant network reaches a mean tract Dice of 0.7468, above VoxelMorph on FA (0.7126), MVCReg on fODF (0.7317) and DDMReg on FA+TOM (0.7417), but below MVVSReg (0.7493) and the classical mrregister (0.7601).
Table 1, page 11
TractSeg bundle Dice (higher is better), averaged over 25 test subjects and 72 tracts; single numbers with no error bars, seeds or per-subject spread reported
Proposed raw-dMRI network vs. mrregister (classical SyN on fODF), VoxelMorph (FA), DDMReg (FA + TOM), MVCReg (fODF), MVVSReg (fODF)
Retrained under the paper's protocol, the raw-dMRI network's mean tract Dice fails to exceed VoxelMorph-on-FA and MVCReg on the same 25 test subjects, or falls clearly below about 0.74.
table
Table 1. Test time performance of various registration methods, average over all 25 test subjects and all 72 available white matter tracts.
https://arxiv.org/abs/2501.04794
https://openreview.net/forum?id=16OdjrftpZ
true
https://paperswithcode.co/paper/2501.04794
2501.09345
Rational Tuning of LLM Cascades via Probabilistic Modeling
[ "Michael Zellinger", "Matt Thomson" ]
poster
journal:TMLR
standard
An LLM cascade sends each query to a small model first and passes it on to a larger, more expensive model only when the current model's confidence is below a threshold. The k-1 thresholds set the trade-off between error rate and inference cost. Tuning them is usually done by grid search or black-box Bayesian optimizati...
Each model's raw confidence (max answer-choice probability for multiple choice, or P('Y') from a self-verification prompt for generation) is calibrated by logistic regression on a hyperparameter-free log transform. The method then fits a joint model of the calibrated confidences of k models. Each marginal is a mixture ...
With n ≤ 30 training examples, Rational Tuning's average test error-cost AUC over the 26 Llama cascades is 0.325, vs. 0.338 for Bayesian optimization (-4.29% on average). It beats BO on all 6 benchmarks, with paired Wilcoxon p < 0.01 on 5 of them (e.g. MMLU -7.74%, p = 1e-6); TruthfulQA (-0.73%, p = 0.12) is not signif...
Table 8, page 18
Area under the test-set error-rate vs. normalized-cost curve (lower is better); %Δ is the mean per-cascade percentage change in AUC; p is from a Wilcoxon test paired by cascade (26 cascades); no seed std reported
Rational Tuning (Markov-copula model + continuous optimization) vs. Bayesian optimization (HEBO) and high-resolution grid search, all tuning the same cascades on the same low-sample training subsets
With the same Llama cascades and a balanced 20-30-example training subsample, Rational Tuning's mean per-cascade AUC reduction vs. Bayesian optimization is near zero or positive on most of MMLU, MedMCQA, XSum and GSM8K, or is not significant under a paired Wilcoxon test.
table
Table 8: Area under the error-cost curve (AUC) in the low-sample limit (n ≤ 30 training examples), showing that our Rational Tuning ("RT") framework for selecting confidence thresholds consistently outperforms both a Bayesian optimization baseline ("BO") and high-resolution grid search ("GS"). The mean percentage chang...
https://arxiv.org/abs/2501.09345
true
https://paperswithcode.co/paper/2501.09345
2502.01226
Adaptive Prior Selection in Gaussian Process Bandits with Thompson Sampling
[ "Jack Sandberg", "Morteza Haghir Chehreghani" ]
poster
main
harder
In Gaussian process (GP) bandits an agent repeatedly picks one of a set of correlated arms to maximise an unknown function drawn from a GP, and its exploration depends on the assumed GP prior (kernel, lengthscale, relevant input dimensions). In practice the prior is unknown and is usually set by maximum likelihood, whi...
Given a finite set of candidate priors P, PE-GP-TS draws one posterior sample f~_{t,p} from each still-active prior and plays the arm and prior that jointly maximise the samples. It then adds the prediction error y_t - mu_{t,p_t}(x_t) to that prior's running total and eliminates the prior if the total exceeds a thresho...
On all three synthetic GP-bandit setups (T = 500, 500 seeds), both Thompson-sampling prior-selection methods have far lower total regret than PE-GP-UCB. Kernel: HP-GP-TS 39.2 ± 1.4 and PE-GP-TS 62.0 ± 0.6 vs. 121.6 ± 1.2. Lengthscale: 31.4 ± 1.0 and 61.8 ± 0.5 vs. 114.2 ± 0.6. Subspace: 88.3 ± 0.9 and 177.1 ± 1.4 vs. 3...
Table 2 (Appendix F), page 28; cumulative-regret curves in Figure 2, page 7
Total cumulative regret at T = 500, averaged over 500 seeds (lower is better); ± is 1 standard error over seeds
HP-GP-TS and PE-GP-TS vs. PE-GP-UCB (Ziomek et al., 2025) given the same candidate prior set, the same reward functions and noise, and the same elimination parameters (delta = 0.05)
On any of the three synthetic setups, HP-GP-TS or PE-GP-TS does not have lower mean total regret than PE-GP-UCB by several standard errors. For example, PE-GP-TS's regret is not clearly below PE-GP-UCB's in the kernel setup (paper: 62.0 vs. 121.6).
table
Table 2: Average total regret and ± 1 standard error for the synthetic and real-world data experiments. The algorithms with the lowest regret (excluding oracle algorithms) are highlighted in bold.
https://arxiv.org/abs/2502.01226
https://openreview.net/forum?id=eCoYINxGo4
true
https://paperswithcode.co/paper/2502.01226
2502.03503
Why Transformers Struggle with Distribution-Independent In-Context Learning
[ "Omar Naim", "Jerome Bolte", "Nicholas Asher" ]
poster
main
standard
In-context learning (ICL) lets a transformer solve a new task from input-output examples in its prompt without weight updates. A common interpretation is that the transformer implements a learning algorithm such as gradient descent or least squares in its forward pass. If it did, its predictions should stay accurate wh...
A GPT-style decoder-only transformer (12 layers, 8 heads, hidden size 256, scalar tokens embedded by a learned linear map and decoded by a learned linear readout, final LayerNorm) is trained from scratch with the Garg et al. (2022) objective: squared error on next-label prediction across prompts (x1, g(x1), ..., xk, g(...
On degree-1 polynomial regression with inputs from U(-1,1), a transformer trained on coefficients from U(-1,1) has MSE 9e-6 at sigma=1, but 4.29 at sigma=5 and 27.06 at sigma=10 when test coefficients come from U(-sigma, sigma). On the same in-context examples, KRR with a polynomial kernel stays at or below 2.3e-3 and ...
Table 1, page 4 (transformer row with ± std in Table 3, page 15)
Test MSE (lower is better). Table 1 gives means with no error bars. Table 3 reports the transformer as mean ± std over 5 evaluation seeds (one trained model, 100 test functions per seed): 4.3 ± 0.2 at sigma=5 and 27.1 ± 2.3 at sigma=10. No error bars are given for the kernel baselines.
Transformer (trained on U(-1,1) coefficients) vs. Nadaraya-Watson (RBF), KRR (RBF) and KRR (polynomial kernel) on identical in-context examples, across coefficient scales sigma in {1,2,3,5,7,10}
A re-trained transformer with the stated setup keeps MSE within the same order of magnitude as KRR (RBF) at sigma=5 and sigma=10 (e.g. below about 0.5 at sigma=10), or its in-distribution MSE at sigma=1 is not near zero (so the in-distribution vs. shifted contrast disappears).
table
Table 1: The evolution of MSE for degree-1 polynomial functions distribution shift, comparing the Transformer with Nadaraya–Watson regression (NW) and kernel ridge regression (KRR). Test inputs are sampled from U(−1, 1) and coefficients from U(−σ, σ). All methods receive the same in-context examples. Kernel hyperparame...
https://arxiv.org/abs/2502.03503
https://openreview.net/forum?id=7Ci5cBtBUO
true
https://paperswithcode.co/paper/2502.03503
2502.10259
MITO: A Millimeter-Wave Dataset and Simulator for Non-Line-of-Sight Perception
[ "Tara Boroushaki", "Laura Dodds", "Cusuh Ham", "Fadel Adib" ]
poster
evaluations_datasets
harder
Millimeter-wave (mmWave) radar signals pass through everyday occluders such as cardboard, fabric and plastic, so they can image objects that cameras cannot see, for example inside a closed box. mmWave images look very different from optical images: they are mostly specular, have edge-diffraction artifacts, no color, an...
The simulator takes a mesh and a set of radar positions. For each position it finds the visible mesh vertices, models each vertex reflection as exp(-j 4π|l−v|/λ_j), sums them into a raw signal, and passes the signals through the same SAR imaging pipeline (Eq. 1) used for real data. There are two variants: a specular si...
Across all objects in MITO, the combined (specular + edge, best weight) simulation matches real 77 GHz mmWave images with a 3D F-score of 85% / 94% / 98% at the 25th / 50th / 75th percentiles, versus 68% / 90% / 97% for specular-only and 49% / 71% / 88% for edge-only simulation.
Table 3, page 6
3D F-score (higher is better) between thresholded, ICP-aligned real and simulated point clouds; percentiles over objects. No error bars or seeds reported.
Combined simulation (best F-score over the weight grid W) vs. specular-only (α1=1, α2=0) vs. edge-only (α1=0, α2=1), all run by the authors on the same objects with the same pipeline
Rerunning the released simulator and evaluation on the MITO real images, the combined simulation's 25th-percentile F-score is not clearly above specular-only (e.g. the 85% vs 68% gap shrinks to a few points), or the median of edge-only is not well below both others.
table
Table 3: Simulation 3D F-Score for combined (Comb), specular (Spec), & edge simulations.
https://arxiv.org/abs/2502.10259
https://openreview.net/forum?id=hJlnaYhXuZ
true
https://paperswithcode.co/paper/2502.10259
2503.01820
RSQ: Learning from Important Tokens Leads to Better Quantized LLMs
[ "Yi-Lin Sung", "Prateek Yadav", "Jialu Li", "Jaehong Yoon", "Mohit Bansal" ]
poster
journal:TMLR
standard
Post-training layer-wise quantization (e.g., GPTQ) compresses an LLM's weights one layer at a time by minimizing the reconstruction error ||WX - W̃X||² on a small calibration set, weighting every token equally. Rotation-based methods like QuaRot first apply orthogonal (Hadamard) transforms to remove weight outliers and...
RSQ (Rotate, Scale, then Quantize) has three steps: (1) rotate the model with a randomized Hadamard matrix as in QuaRot; (2) scale each token's input features by an importance score r_i, giving the weighted objective sum_i ||r_i (W x_i - W̃ x_i)||², which is equivalent to running GPTQ with the modified Hessian H = 2 X ...
Quantizing LLaMA3-8B-Instruct to 3-bit with 256×4096-token WikiText-2 calibration, RSQ reaches WikiText-2 perplexity 9.046 ± 0.01 and 10-task average accuracy 65.4 ± 0.1%, versus 9.517 ± 0.11 and 63.8 ± 0.5% for QuaRot under the same setup.
Table 2, page 6
WikiText-2 perplexity (lower is better, context length 2048) and average accuracy over 10 downstream tasks (higher is better); ± is the std across three runs (seeds)
RSQ (rotation + AttnCon token scaling + dataset expansion + GPTQ) vs. QuaRot (rotation + GPTQ with uniform token weights) and GPTQ, same model, bit-width and calibration data
On LLaMA3-8B-Instruct at 3-bit with matched calibration data and seeds, RSQ's WikiText-2 perplexity is not lower than QuaRot's by more than the seed std (i.e., the ~0.47 perplexity gap shrinks to within ~0.1), or RSQ's average accuracy is not above QuaRot's by more than about one std (~0.5 points).
table
Table 2. Comparison of recent layer-wise quantization approaches with RSQ on multiple downstream tasks. We report perplexity for WikiText and accuracy for all other tasks. The model is quantized to 3-bit. The best-performing method across all quantization approaches is highlighted in bold. We denote the standard deviat...
https://arxiv.org/abs/2503.01820
true
https://paperswithcode.co/paper/2503.01820
2503.07338
Aligned Delta-Triplane Transformers as Occupancy World Models
[ "Haoran Xu", "Peixi Peng", "Shijun Guo", "Guang Tan", "Yiqian Chang", "Yisen Zhao", "Shuaixian Wang", "Yonghong Tian" ]
poster
main
standard
Occupancy world models predict future 3D semantic voxel grids around an autonomous vehicle from past occupancy frames and the ego vehicle's past and planned motion. Most existing models compress each frame into a bird's-eye-view latent, use a large Transformer or diffusion model to align past frames implicitly, and pre...
ADTT first pretrains a triplane autoencoder (xy, xz, yz feature planes, 16x100x100, 8 channels) to reconstruct 16x200x200 Occ3D-nuScenes occupancy grids. Historical triplanes are then explicitly warped into the target ego frame using the recorded ego poses (nearest-neighbour sampling, zeros where there is no historical...
On Occ3D-nus 3-second forecasting, full ADTT reaches 46.87 average mIoU and 52.63 IoU. Removing triplane motion compensation drops this to 31.87 mIoU and 37.48 IoU, and predicting the full future state instead of deltas drops it to 36.65 mIoU and 45.50 IoU.
Table 4, page 8
Average mIoU (%) over 18 semantic classes and average occupancy IoU (%) across 1 s, 2 s and 3 s horizons, higher is better. Single runs with no seeds, std or confidence intervals reported.
Full ADTT (M0) vs. the same model without motion compensation (M4) and without delta prediction (M5), under the same training settings
Retrained variants without motion compensation, or with full-state instead of delta prediction, come within a few mIoU points of the full model (e.g. a gap under about 3 mIoU instead of 15 and 10), or match or beat it.
table
Table 4: Ablation on key designs in ADTT.
https://arxiv.org/abs/2503.07338
https://openreview.net/forum?id=TVtLbFPjtb
true
https://paperswithcode.co/paper/2503.07338
2504.02273
Reasoning Under 1 Billion: Memory-Augmented Reinforcement Learning for Large Language Models
[ "Hung Le", "Van Dai Do", "Dung Nguyen", "Svetha Venkatesh" ]
poster
journal:TMLR
standard
RL fine-tuning with outcome rewards (as in DeepSeek-R1) improves chain-of-thought reasoning in large LLMs, but tiny models (1B parameters or fewer) rarely produce correctly formatted, correct answers early in training, so outcome rewards are sparse. Adding format-based rewards helps, but small models tend to overfit to...
Memory-R+ keeps two kNN episodic memories of past (query, responses) pairs, one for successful responses (correct answer) and one for failed ones, with queries and responses embedded by the all-MiniLM-L6-v2 Sentence Transformer. For a new query, the K most similar stored queries (cosine similarity) are retrieved. The e...
Fine-tuning Qwen2.5-0.5B-Instruct on 2,000 AI-MO samples, Memory-R+ (K = 20) reaches about 37.5-38% GSM8K test accuracy from step 100 onward, versus about 33-34.5% for both R1 and Cosine, a gap of roughly 4 points with non-overlapping std bands over 3 seeds.
Figure 2 (GSM8K panel), page 7; Memory-R+ K = 20 exact values in Table 2, page 8
GSM8K test extractive-match accuracy (Lighteval, zero-shot), higher is better; mean ± std over 3 training seeds (shaded bands)
Memory-R+ (K = 20) vs. R1 (GRPO with correctness + format rewards) vs. Cosine (adds length-based reward), same model, data and hyperparameters
With 3 seeds per method, Memory-R+'s GSM8K accuracy at the final checkpoint is not above both R1 and Cosine by more than the seed std, or the gap is under about 2 points.
figure
Figure 2: Performance of fine-tuning Qwen2.5-0.5B-Instruct on AI-MO data. The test accuracy is evaluated at multiple checkpoints during training (mean±std. over 3 runs).
https://arxiv.org/abs/2504.02273
true
https://paperswithcode.co/paper/2504.02273
2505.13775
Beyond Semantics: The Unreasonable Effectiveness of Reasonless Intermediate Tokens
[ "Karthik Valmeekam", "Vardhan Palod", "Kaya Stechly", "Atharva Gundawar", "Subbarao Kambhampati" ]
poster
journal:TMLR
standard
Reasoning models are trained to emit intermediate tokens ('chains of thought') before an answer, and these traces are often read as faithful records of the model's reasoning. It is unclear whether the semantic correctness of the traces is what makes them useful. In large pretrained models this cannot be checked, becaus...
The authors train a Qwen2.5-0.5B architecture from scratch with a custom 944-token vocabulary (~380M parameters, 32k context) on 30x30 maze shortest-path problems. Each training example is a maze description, start and goal, a linearized A* execution trace (create/close x y cG cH operations, Manhattan heuristic), and t...
For models trained from scratch on 500k SF-style maze problems, training on traces swapped between problems gives higher plan accuracy than training on correct A* traces, on both initialization seeds: 89.1% and 86.8% vs. 56.2% and 64.9% on in-distribution SF-style mazes, and 95.4% and 87.8% vs. 62.1% and 66.3% on out-o...
Table 6, page 19 (Appendix A.2); seed-1 values also in Table 3, page 10
Plan accuracy (%) on 1000 test problems per maze generator, higher is better; trace validity within valid plans (%) is also shown. No ± reported; two training seeds (original and Seed 2) are reported as separate rows.
Swapped (SF-style) vs. Normal (SF-style), same architecture, same problems and plans, same training budget, matched per initialization seed
A Normal (correct-trace) SF-style model trained under the same setup reaches plan accuracy within a few points of, or above, the Swapped model on the SF-style or Drunkard test sets, or the Swapped model's advantage disappears on a fresh seed.
table
Table 6: SF-style model performance across seeds. Original denotes the models whose performance were reported at Table 3. Seed 2 are the models trained on a different seed. Each cell shows Plan Accuracy (%) / Trace Validity within valid plans (%).
https://arxiv.org/abs/2505.13775
true
https://paperswithcode.co/paper/2505.13775
2505.15405
HOPSE: Scalable Higher-Order Positional and Structural Encoder for Combinatorial Representations
[ "Guillermo Bernárdez", "Marco Montagna", "Louis Van Langendonck", "Martin Carrasco", "Amirreza Akbari", "Louisa Cornelis", "Mathilde Papillon", "Pere Barlet-Ros", "Nina Miolane", "Lev Telyatnikov" ]
poster
main
standard
Topological deep learning models data on higher-order domains such as simplicial and cell complexes, where nodes, edges and faces (triangles, cycles) all carry features. Most topological neural networks use higher-order message passing (HOMP) between cells of different ranks, which is expressive but slow, because the n...
HOPSE splits a complex into a set of strictly augmented Hasse graphs, one for each chosen neighborhood function (adjacencies A_{r,s} and incidences I_{s->t} between cells of different ranks). On each Hasse graph it computes standard graph positional and structural encodings once, as preprocessing. The encodings for cel...
On MANTRA second-Betti-number prediction (simplicial domain), HOPSE-M-C reaches 83.70 ± 0.99, above the best higher-order message-passing baselines TopoTune (80.37 ± 1.62) and SCCNN (79.62 ± 1.23), and far above GIN (56.11 ± 0.53).
Table 1, page 8
Test score on the beta_2 task, higher is better (the paper says accuracy/F1 for up-arrow tasks without naming the exact one for beta_2); mean ± std over 5 seeds at the best validation configuration. The paper's 95% significance marking shows no other model tied with HOPSE-M-C in this column.
HOPSE-M-C vs. simplicial HOMP baselines TopoTune, SCCNN, SANN and graph baselines GCN, GAT, GIN, all under the same TopoBench protocol and hyperparameter search
Under the same protocol and search, HOPSE-M-C's mean beta_2 score is not higher than TopoTune's or SCCNN's, or the gap shrinks to within one std of either baseline.
table
Table 1: Overall Results Table. Evaluation of predictive performance on molecular and topological benchmarks. We report the test mean ± standard deviation over 5 seeds for best validation configurations. Bold highlights the top-performing model per column, while blue denotes models with no statistically significant dif...
https://arxiv.org/abs/2505.15405
https://openreview.net/forum?id=5B4SMDYGLq
true
https://paperswithcode.co/paper/2505.15405
2505.21938
Practical Adversarial Attacks on Stochastic Bandits via Fake Data Injection
[ "Qirun Zeng", "Eric He", "Richard Hoffmann", "Xuchuang Wang", "Jinhang Zuo" ]
poster
main
standard
Adversarial attacks on stochastic multi-armed bandits usually assume the attacker can change the reward of the chosen arm in every round, by any amount. Real systems such as recommenders and ad platforms do not allow this: an adversary cannot overwrite genuine user feedback but can create fake accounts that add a limit...
The attacks use a suppression principle. Once a non-target arm i has been pulled ⌈log T / δ0²⌉ times, the attacker injects enough fake samples with reward r_min to push its empirical mean below a high-probability lower bound on the target arm's mean, ℓ̂_K(t) = µ̂_K(t) − 2β(N_K(t)) − 3σδ0. After that, UCB essentially ne...
Against UCB on a 10-arm MovieLens Bernoulli bandit with the least popular movie as target, SBI and PBI make the learner select the target arm in 99.68% of rounds at T = 10^6, with attack cost C^F(T) of about 3,800, while a random-timing heuristic with exactly the same fake samples (same cost) reaches only 0.02%.
Figure 1b (and 1a), page 10; numbers stated in Section 5, page 9
Target-arm selection ratio (higher is better for the attacker) and attack cost C^F(T) (cumulative reward deviation of fake samples, lower is better); means over 20 runs, shading = one sample standard deviation; values other than 99.68% / 0.02% are read off the plot and approximate
SBI and PBI (suppression-timed injection) vs. a random-timing heuristic with matched fake rewards and per-arm counts; LI (one optimized fake sample per arm) also shown
Re-running the UCB setup (K = 10 MovieLens arms, σ = 0.5, δ0 = 0.2, δ = 0.05, f = 10, T = 10^6, 20 runs), SBI/PBI's target-arm ratio falls well below ~95%, or the matched-cost random-timing heuristic reaches a comparable ratio, or SBI/PBI's attack cost grows roughly linearly in T instead of flattening near a few thousa...
figure
Figure 1: UCB experiments with 20 repetitions. Shading shows one sample standard deviation. Panels: (a) Attack cost vs. T, (b) Target-arm ratio vs. T. Methods: SBI, PBI, LI, Heuristic.
https://arxiv.org/abs/2505.21938
https://openreview.net/forum?id=rmGDkBbxpE
true
https://paperswithcode.co/paper/2505.21938
2505.22252
B-XAIC Dataset: Benchmarking Explainable AI for Graph Neural Networks Using Chemical Data
[ "Magdalena Proszewska", "Tomasz Danel", "Antoni Antoszek", "Dawid Damian Rymarczyk" ]
poster
evaluations_datasets
standard
Graph neural networks are the standard model for predicting molecular properties, and many explainability (XAI) methods claim to show which atoms and bonds drive a prediction. Evaluating these explainers is hard because real molecular datasets rarely have known ground-truth rationales, and existing benchmarks are eithe...
B-XAIC samples 50K molecules from ChEMBL 35 (8/1/1 random split) and labels them for 7 rule-based binary tasks: presence of boron (B), phosphorus (P), halogens (X), indole, PAINS alerts, more than four rings (rings-count), and a ring with more than six atoms (rings-max). Each positive molecule has node- and edge-level ...
On B-XAIC with a trained GIN, node-level gradient-based explainers other than Deconvolution score low on null explanations (Saliency 0.51 ± 0.12, InputXGradient 0.54 ± 0.14, GuidedBackprop 0.41 ± 0.12, IntegratedGradients 0.39 ± 0.26, averaged over 7 tasks) while PGMExplainer scores 0.98 ± 0.02 and SubgraphX 0.94 ± 0.0...
Table 4, page 7
NE: fraction of pattern-free molecules whose node attributions contain no 1.5x IQR outliers (higher is better). SE: node-level AUROC against ground-truth pattern atoms (higher is better). Values are means over the 7 tasks; the ± is the standard deviation across the 7 tasks (the Table 4 caption says only 'uncertainty', ...
Gradient-based explainers (Saliency, GuidedBackprop, IntegratedGradients, InputXGradient) vs. PGMExplainer and SubgraphX, all applied to the same trained GIN on the same B-XAIC test set.
Using a GIN trained to similar accuracy on B-XAIC, Saliency (or IntegratedGradients/GuidedBackprop) reaches a task-averaged node NE within about 0.2 of PGMExplainer, or PGMExplainer's node NE falls below about 0.8.
table
Table 4: Evaluation of the node and edge explanations for the GIN model. Explainers are grouped as gradient-based (GB), graph-specific (GS), perturbation-based (PB), and surrogate (SU). Bold marks the best score and those not significantly worse (one-sided Wilcoxon test). Avg is the mean of NE and SE; uncertainty is re...
https://arxiv.org/abs/2505.22252
https://openreview.net/forum?id=GHoBerj4sM
true
https://paperswithcode.co/paper/2505.22252
2505.22919
ER-Reason: A Benchmark Dataset for LLM Clinical Reasoning in the Emergency Room
[ "Nikita Mehandru", "Niloufar Golchini", "Namrata Garg", "Kathy T LeSaint", "Christopher J Nash", "Anu Ramachandran", "Travis Zack", "Liam Greg McCoy", "Adam Rodman", "David Bamman", "Melanie Molina", "Ahmed Alaa" ]
poster
evaluations_datasets
harder
LLMs score well on medical-licensing-style multiple-choice benchmarks, but prospective studies show much weaker clinical usefulness. A common critique is construct validity: most benchmarks measure knowledge recall or final diagnostic accuracy on stylized vignettes rather than clinical reasoning. The paper defines clin...
Emergency medicine attendings wrote 194 SCT-style cases from real ER provider notes. Each case gives a clinical scenario, 3-5 candidate diagnoses and a sequence of evidence steps (a lab, imaging, or exam finding), for 787 SCT items in total. At each step the respondent rates how the new evidence changes the likelihood ...
On the 194-case ER-Reason SCT set, giving the model the physician's rationale for the current step (single oracle) raises DxUpdate for every one of 8 LLMs above the upper end of its zero-shot 95% CI, e.g. GPT-5.2 0.677 (0.646-0.701) -> 0.795 and o4-mini 0.691 (0.664-0.713) -> 0.809; DxTrajectory rises likewise (GPT-5.2...
Table 2, page 7
DxUpdate = linearly weighted Cohen's kappa vs. physician consensus (higher is better); DxTrajectory = mean Spearman rho of differential rankings (higher is better). Parentheses are 95% CIs from 1,000 bootstrap resamples, reported for zero-shot only; SO/FO are point estimates with no CI. One run per condition.
Same model, same cases: zero-shot vs. single-oracle vs. full-oracle prompting, for each of 8 LLMs
For the same (or comparable current) models, single-oracle DxUpdate or DxTrajectory falls inside the zero-shot bootstrap 95% CI (a gain of less than roughly 0.03-0.04) for most models.
table
Table 2: Performance in SCT reasoning tasks. (95% confidence intervals reported from 1,000 bootstraps.)
https://arxiv.org/abs/2505.22919
https://openreview.net/forum?id=tI6dUEC7KR
true
https://paperswithcode.co/paper/2505.22919
2505.23086
Equivariant Spherical Transformer for Efficient Molecular Modeling
[ "Junyi An", "Xinyu Lu", "Yun-Fei Shi", "Peijia Lin", "Qianwei Tang", "Li-Cheng Xu", "Chao Qu", "Fenglei Cao", "Yuan Qi" ]
poster
main
harder
SE(3)-equivariant graph neural networks for molecules and materials usually build interactions from Clebsch-Gordan tensor products of steerable (spherical-harmonic) features. These products get expensive as the maximum degree L grows, and a fixed L limits what the network can express. For example, Joshi et al. showed t...
The Equivariant Spherical Transformer (EST) maps each node's steerable features (degrees 0..L, C channels) onto S near-uniform sample points on the sphere (a Fibonacci lattice, optionally refined by repulsion). This gives a length-S sequence of C-dimensional vectors. EST applies pre-LayerNorm self-attention across all ...
A single EST layer with maximum degree L = 1 distinguishes 3-fold, 10-fold and 100-fold rotationally symmetric structures with 100.0 ± 0.0% accuracy, while a TFN/MACE tensor-product layer with L = 1 stays at chance (50.0 ± 0.0%) on 2-, 3-, 5- and 10-fold structures, and in general fails whenever n > L.
Table 5, page 9
Classification accuracy (%) for distinguishing the symmetric structure pair (higher is better; 50% = chance). The paper reports ± values but does not define them or state the number of runs or seeds.
EST layer vs. TFN/MACE tensor-product layer at the same maximum degree L (1, 2, 3, 5, 10); the 3-fold and 10-fold columns are shared by both.
An L = 1 EST layer (trained with the paper's setup and Fibonacci-lattice sampling) scores near 50% on 3-fold or 10-fold structures, or a TFN/MACE L = 1 layer, run under the same protocol, distinguishes those structures well above chance.
table
Table 5: Experiments on Rotationally symmetric structures.
https://arxiv.org/abs/2505.23086
https://openreview.net/forum?id=5i7KqZASE3
true
https://paperswithcode.co/paper/2505.23086
2505.23458
Diffusion Guidance Is a Controllable Policy Improvement Operator
[ "Kevin Frans", "Seohong Park", "Pieter Abbeel", "Sergey Levine" ]
poster
main
standard
Offline RL tries to learn a policy that is better than the behavior in a fixed dataset, but most methods that do so are harder to tune and less stable than plain behavioral cloning. Goal-conditioned behavioral cloning (GCBC) is simple and scalable, yet it only imitates the data and does not converge to the optimal goal...
A single flow-matching policy network is trained with the standard conditional flow-matching loss, conditioned on state and on a goal g that is dropped (set to null) 10% of the time, so the same network represents both the unconditional BC policy and the goal-conditioned GCBC policy. Goals are sampled uniformly from fu...
On OGBench pointmaze-giant-navigate (state-based, oraclerep), a flat flow policy sampled with CFG weight w = 3 (CFGRL) reaches 30 ± 10% success versus 4 ± 2% for flow GCBC (w = 1) and 2 ± 2% for Gaussian GCBC; on humanoidmaze-medium-navigate it reaches 19 ± 6% versus 8 ± 3% for flow GCBC.
Table 3, page 9
Goal-reaching success rate (%) on OGBench evaluation goals, higher is better; ± is standard deviation over 8 seeds (state-based tasks) or 4 seeds (pixel tasks)
CFGRL (flow policy, guidance w = 3) vs. flow GCBC (w = 1), flow BC (w = 0), Gaussian GCBC and Gaussian BC, all trained without a value function
On pointmaze-giant-navigate with 8 seeds, CFGRL at w = 3 does not exceed flow GCBC by more than the seed std (e.g. CFGRL mean below ~15% while flow GCBC stays near 4%), or on humanoidmaze-medium-navigate CFGRL is not above flow GCBC.
table
Table 3: Improving on GCBC. CFGRL consistently improves performance over GCBC across the board. Numbers at or above the 95% of the best performance in each category are boldfaced, as in OGBench [57].
https://arxiv.org/abs/2505.23458
https://openreview.net/forum?id=aQYvs5JZpu
true
https://paperswithcode.co/paper/2505.23458
2505.24791
Accelerating Inference of Discrete Autoregressive Normalizing Flows by Selective Jacobi Decoding
[ "Jiaru Zhang", "Juanwu Lu", "Xiaoyu Wu", "Ziran Wang", "Ruqi Zhang" ]
poster
journal:TMLR
standard
Autoregressive normalizing flows such as TarFlow reach state-of-the-art likelihoods and image quality by splitting an image into a sequence of patches and transforming each one conditioned on all previous ones with a causal transformer. Training is parallel, but sampling requires inverting every flow block, and the inv...
Inverting one autoregressive flow block is treated as solving a triangular system of L nonlinear equations. Jacobi decoding (Algorithm 1) starts from z^0 = 0 and, in each iteration, recomputes every patch z_{k,l} in parallel from the previous iterate's prefix z^{t-1}_{k,<l} and the block input z_{k+1}, stopping when th...
On AFHQ 256x256 with the released TarFlow checkpoint, selective Jacobi decoding generates a batch of 256 in 41.21 s vs. 186.28 s for sequential inference (4.5x faster) and 219.24 s for uniform Jacobi decoding, with FID 15.44 vs. 15.42 (sequential) and 15.44 (UJD).
Table 1, page 8
Wall-clock time per batch in seconds (lower is better; mean over 10 batches, two L40S GPUs) and FID (lower is better). For AFHQ no error bars are reported (single run); for CIFAR-10/100 the ± is the maximum deviation over three runs.
Selective Jacobi Decoding vs. standard sequential inference with KV cache and uniform Jacobi decoding (all blocks), same checkpoint, tau = 0.5, zero initialization
On the released AFHQ checkpoint, SJD gives less than about a 2x wall-clock speedup over a properly KV-cached sequential sampler at the same batch size and hardware, or its FID rises by more than about 0.5 over sequential sampling, or UJD turns out to be as fast as SJD.
table
Table 1: Comparison of sequential inference, uniform Jacobi decoding, and our approach. The subscript indicates the maximum deviation in three runs.
https://arxiv.org/abs/2505.24791
true
https://paperswithcode.co/paper/2505.24791
2506.01197
Incorporating Hierarchical Semantics in Sparse Autoencoder Architectures
[ "Mark Muchane", "Sean M Richardson", "Kiho Park", "Victor Veitch" ]
poster
main
harder
Sparse autoencoders (SAEs) decompose language-model activations into a dictionary of sparse, ideally interpretable features. Larger dictionaries reconstruct activations better, but they tend to split one concept into many narrow features and to absorb features into one another, which hurts interpretability. Standard SA...
The Hierarchical SAE (H-SAE) is a top-level TopK SAE (encoder E, decoder D, LeakyReLU then TopK with k = 32, no bias, unit-normalized inputs) in which every top-level atom j has its own expert: a trainable down-projection to an s-dimensional subspace, a small low-level SAE with m_low sublatents that keeps only its top-...
On layer-20 Gemma 2-2B residual activations with k = 32, the H-SAE has lower 1 - explained variance than a standard TopK SAE of the same top-level width at 8k, 16k and 32k latents (e.g. 32k: about 0.29 with 16 sublatents and 0.26 with 64, vs. 0.33 for the SAE), and the 8k x 64 H-SAE (about 0.327) matches the 32k standa...
Figure 3, page 7
1 - explained variance and 1 - SAEBench CE loss score (both lower is better); single runs, no error bars or seeds reported
H-SAE with 16 and 64 sublatents per expert vs. standard TopK SAE, at 8k/16k/32k top-level latents, same data, k and training schedule
With matched width, k, data and training, the H-SAE's 1 - explained variance (or 1 - CE loss score) is not lower than the TopK SAE's at most widths, or the gap at a given width is much smaller than reported (e.g. under 0.01 FVU), or the 8k x 64 H-SAE is clearly worse than the 32k TopK SAE.
figure
Figure 3: H-SAEs have better reconstruction performance as measured by explained variance and the downstream CE loss of a Gemma 2-2B using SAE-reconstructed activation vectors. (a) 1 - CE Loss score across model sizes with 16 and 64 sublatents per expert (SAEBench CE loss score; lower is better). (b) 1 - Explained Vari...
https://arxiv.org/abs/2506.01197
https://openreview.net/forum?id=bxzKrp5LXO
true
https://paperswithcode.co/paper/2506.01197
2506.02546
To trust or not to trust: Attention-based Trust Management for LLM Multi-Agent Systems
[ "Pengfei He", "Zhenwei Dai", "Xianfeng Tang", "Yue XING", "Hui Liu", "Jingying Zeng", "Qiankun Peng", "Shrivats Agrawal", "Samarth Varshney", "Suhang Wang", "Jiliang Tang", "Qi He" ]
poster
main
harder
LLM multi-agent systems pass messages between agents, and each agent treats incoming messages as trusted context. Compromised agents, intercepted channels, or injected misinformation can therefore corrupt the whole system. Existing defenses usually target a single kind of harm, such as factual errors, and rely on promp...
The authors define six trust dimensions (factual accuracy, logical consistency, relevance, bias, clarity, language quality) and build a Trust Violation dataset (>20k samples). In each sample, a message M, paired with a context C (benign agent profile plus a math, code, or QA task), violates exactly one dimension or non...
Across all 4 datasets x 3 agent structures x 4 attacks (48 settings), A-Trust's message detection rate ranges from 77.1% to 90.4%, while the best baseline (perplexity or prompt-based) ranges from 50.5% to 67.7%. A-Trust leads the best baseline in every setting, by margins of 10.9 to 32.2 points (e.g. MMLU-Phy Chain Aut...
Table 1, page 7
Message Detection Rate (%), higher is better: the fraction of malicious messages flagged by the trust system. The 'Clean' column (lower is better) is the fraction of messages flagged on correctly solved clean queries. No error bars, seeds or sample counts are reported.
A-Trust (attention-based logistic-regression probes on Llama3.1-8B-Instruct) vs. perplexity-based score (Llama3.1-8B) and prompt-based six-dimension trust score (GPT-4o), all plugged into the same trust management system and multi-agent setup
In a reproduction, A-Trust's MDR does not exceed the better of the two baselines by at least ~10 points in most of the (dataset, structure, attack) settings, or A-Trust's clean false-detection rate rises well above ~10%.
table
Table 1: Message Detection Rate (MDR) of different attacking methods on various datasets and agent structures, and higher rates denote better performance. Note that the clean detection rate is the proportion of messages detected as malicious on the queries correctly solved by the system, and a smaller value indicates b...
https://arxiv.org/abs/2506.02546
https://openreview.net/forum?id=tRFYHQFSH4
true
https://paperswithcode.co/paper/2506.02546
2506.06361
Tactile MNIST: Benchmarking Active Tactile Perception
[ "Tim Schneider", "Guillaume Duret", "Cristiana de Farias", "Roberto Calandra", "Liming Chen", "Jan Peters" ]
spotlight
evaluations_datasets
harder
Tactile sensors such as the GelSight Mini give rich but very local information, so an agent has to choose where to touch and combine many touches over time to recognise an object (active tactile perception). The field has no standard benchmark. The paper introduces ap_gym (a Gymnasium-compatible active perception frame...
The task is TactileMNIST classification with 16 touches per episode. Training uses TactileMNISTSnap, where each step the commanded sensor position snaps to the closest of 16 uniformly sampled positions. Real evaluation uses TactileMNISTRealSnap, which replays recorded real touches from the test split: the commanded pos...
With the full sim-to-real recipe, APPLE-SAC trained only in simulation reaches 65.7 ± 4.3% final classification accuracy on real TactileMNIST test digits. Removing the CycleGAN gives 12.4 ± 1.7%, removing the real-image round trip gives 19.0 ± 2.1%, and removing the background depth overlay gives 31.9 ± 7.7%. Simulated...
Figure 42, page 44 (numbers in the Appendix H text, pages 44-45)
Final-step classification accuracy (%) on TactileMNISTRealSnap test split (higher is better), averaged over evaluations between 2.0M and 2.5M env steps; ± is std over 5 seeds. Chance is 10%.
Full recipe vs. four single-component ablations (no CycleGAN / no real-image round trip / no background depth overlay / no contact geometry variation), all APPLE-SAC, same training budget; real vs. simulated accuracy for each.
The full recipe's real-data accuracy falls to or below the 'no real-image round trip' or 'no background depth overlay' ablation (or stays within about one std of either), or the full recipe does not clearly beat chance (10%) on the real test split.
figure
Figure 42: Final classification accuracy of APPLE-SAC on real (TactileMNISTRealSnap, test split; solid) and simulated tactile data (TactileMNISTSnap; light) for the full sim-to-real recipe and its ablations. Each ablation removes one component from the full recipe; without the CycleGAN, we render with Taxim during trai...
https://arxiv.org/abs/2506.06361
https://openreview.net/forum?id=3yMkqerEOt
true
https://paperswithcode.co/paper/2506.06361
2507.14760
QUTCC: Quantile Uncertainty Training and Conformal Calibration for Imaging Inverse Problems
[ "Cassandra T Ye", "Shamus Li", "Tyler King", "Kristina Monakhova" ]
poster
main
harder
Deep networks used for image reconstruction (denoising, accelerated MRI, phase microscopy) can produce plausible-looking but wrong outputs, so users want pixel-wise error bars with a statistical guarantee. Conformal methods for image-to-image regression, such as Im2Im-UQ (RCPS calibration) and K-RCPS, take heuristic qu...
QUTCC trains a single attention U-Net f_θ(y, q) with a sinusoidal quantile embedding (as in diffusion time embeddings), fed to every residual block. At each training step q ~ U(0,1) is sampled per image and used both as the conditioning input and as the level of the pinball loss, so the network learns the full conditio...
On synthetic Poisson denoising of FMD images calibrated to α = 0.1, QUTCC's interval length for bright pixels (intensity 0.80–1.00) is 0.187 ± 0.034, versus 0.225 ± 0.028 for K-RCPS and 0.294 ± 0.042 for Im2Im-Asymm (0.60–0.80 bin: 0.158 vs. 0.207 and 0.238), with mean interval length 0.040 vs. 0.046–0.047 (Table 6).
Table 1, page 8 (mean lengths and risks: Table 6, page 18)
Calibrated uncertainty-interval length (upper minus lower bound, in normalized intensity units), lower is better, at target total pixel miscoverage α = 0.1. The paper does not define ± for Tables 1 and 6; it appears to be the spread over test pixels/images within the bin, not over seeds. No seed repeats are reported.
QUTCC vs. the other conformal methods on the same deep attention U-Net backbone: Im2Im (single λ), Im2Im-Asymm (two λ), K-RCPS (k = 2). MC-Dropout and Deep Ensembles are also listed but are not the central comparison.
With the same backbone, data split and α = 0.1, QUTCC's calibrated interval length in the 0.60–1.00 intensity bins on Poisson denoising is not smaller than K-RCPS's by more than the reported per-bin spread, or QUTCC only achieves the shorter intervals while its test risk exceeds 0.1, or the gap disappears when the base...
table
Table 1: Uncertainty interval length stratified by pixel intensity. Blue entries denote the smallest uncertainty intervals within each bin, while bold black entries indicate the second smallest.
https://arxiv.org/abs/2507.14760
https://openreview.net/forum?id=hIqpI82zrU
true
https://paperswithcode.co/paper/2507.14760
2507.14777
Understanding the Interplay between Memorization and Learning in Large Language Models
[ "Bishwamittra Ghosh", "Soumi Das", "Qinyuan Wu", "Mohammad Aflah Khan", "Deepak Garg", "Krishna Gummadi", "Evimaria Terzi" ]
poster
evaluations_datasets
harder
Memorization in LLMs is usually measured by how well a model recalls a training string, which mixes up rote memorization with recall that comes from having learned the language (for example, counting to 1000). The paper proposes 'contextual memorization': a training string counts as memorized only once its training los...
Mistral-7B is fine-tuned for 50 epochs (batch size 8, learning rate 5e-6, linear schedule with 0.05 warm-up) on strings sampled from a formal language (L2, L4 or L9, defined in Appendix F) and evaluated on 1024 held-out test strings from the same language. The 'optimal learning epoch' is the epoch with the lowest mean ...
When Mistral-7B is fine-tuned on formal language L2, MAT gives lower weighted contextual memorization at the optimal-learning epoch than base training (about 0.02 vs. 0.21) and lower test-loss std (about 0.090 vs. 0.094), with mean test loss no worse (about 0.177 vs. 0.188). MAT's memorization is also below base traini...
Figure 61, page 64 (appendix J.1); summary version for L2 in Figure 9, page 10
Weighted contextual memorization at the optimal-learning epoch (lower is better). Also reported: std and mean of test cross-entropy loss over 1024 test strings at that epoch (lower is better), and cumulative number of training strings. Points are averages over runs; no error bars or ± values are reported.
MAT vs. base training and deduplication (and MAT*), same model, data and hyperparameters, on languages L2, L4 and L9
Re-running base training and MAT on L2 with the released code and several seeds, MAT's weighted contextual memorization at the optimal epoch is not clearly lower than base training's (for example, within seed variability, or not at least halved), or MAT's mean test loss is clearly higher than base training's.
figure
Figure 61: Summary results on learning, memorization, and training cost efficiency on different formal languages, averaged across multiple runs. Lower values are better in all dimensions.
https://arxiv.org/abs/2507.14777
https://openreview.net/forum?id=oG5alWKa3Z
true
https://paperswithcode.co/paper/2507.14777
2507.21183
MaPPO: Maximum a Posteriori Preference Optimization with Prior Knowledge
[ "Guangchen Lan", "Sipeng Zhang", "Tianle Wang", "Yuwei Zhang", "Xinpeng Wei", "Daoan Zhang", "Xiaoman Pan", "Hongming Zhang", "Dong-Jun Han", "Christopher Brinton" ]
poster
main
standard
Direct Preference Optimization (DPO) aligns an LLM with preference pairs by maximizing the likelihood that the chosen response beats the rejected one under a Bradley-Terry model. The loss depends only on the gap between the two responses. So DPO pushes them apart even when both are good (near-ties), and it is known to ...
MaPPO turns the DPO maximum-likelihood objective into a maximum a posteriori objective by using the reward model's scores as a prior. In practice, the implicit reward of the rejected response is scaled by the reward gap: L = -log σ(β log[πθ(yw|x)/πref(yw|x)] - Δr · β log[πθ(yl|x)/πref(yl|x)]), with Δr = rw - rl ∈ [0, 1...
With offline training on UltraFeedback prompts and Qwen2.5-3B-Instruct, DPO+MaPPO reaches 26.68 AlpacaEval 2.0 LC win rate and 35.1 Arena-Hard win rate, against 20.16 and 29.2 for DPO trained the same way. That is gains of +6.52 and +5.9, well above the reported evaluation error (AlpacaEval SE ≈1.0-1.7, Arena-Hard CI ≈...
Table 3, page 9
AlpacaEval 2.0 length-controlled win rate (%) and Arena-Hard v0.1 win rate (%), both judged by GPT-4 Turbo, higher is better. The table has no per-cell error bars. The text reports AlpacaEval standard errors of 1.02-1.67 across model sizes and Arena-Hard 95% CIs of about ±1.5; these are judge-sampling errors, not varia...
Offline DPO+MaPPO vs. offline DPO on Qwen2.5-3B-Instruct, with the same preference data, reward model and hyperparameters.
With the same pipeline on Qwen2.5-3B-Instruct, DPO+MaPPO beats DPO by less than about 2 points (≈ the reported SE) on AlpacaEval 2.0 LC, or by less than about 1.5 points (≈ the reported CI) on Arena-Hard, or DPO comes out ahead.
table
Table 3: Main evaluation results on three standard benchmarks. ↑ indicates the higher the better.
https://arxiv.org/abs/2507.21183
https://openreview.net/forum?id=q5WDC6dLm9
true
https://paperswithcode.co/paper/2507.21183
2508.10104
DINOv3
[ "Oriane Siméoni", "Huy Vo", "Maximilian Seitzer", "Federico Baldassarre", "Maxime Oquab", "Cijo Jose", "Vasil Khalidov", "Marc Szafraniec", "Seung Eun Yi", "Michaël Ramamonjisoa", "Francisco Massa", "Daniel Haziza", "Luca Wehrstedt", "Jianyuan Wang", "Timothée Darcet", "Théo Moutakanni...
poster
journal:JMLR
harder
Self-supervised vision foundation models such as DINOv2 are used as frozen, general-purpose image encoders, and the quality of their per-patch (dense) features determines how well they serve segmentation, depth estimation and correspondence without fine-tuning. Long, large-scale self-supervised training is known to imp...
DINOv3 7B is trained with the DINO/iBOT self-distillation objectives on a curated 1.7B-image web dataset, followed by a Gram anchoring phase that regularizes the Gram matrix of patch features toward that of an earlier teacher checkpoint, and a high-resolution adaptation phase. Smaller ViTs (patch size 16) are distilled...
With frozen backbones and a linear probe on patch features, the distilled DINOv3 ViT-L/16 reaches 54.9 mIoU on ADE20k and 0.352 RMSE on NYUv2 depth, versus 48.8 mIoU and 0.394 RMSE for DINOv2 ViT-L/14 (with registers) at a matched number of patch tokens; the same ordering holds at ViT-B (51.8 vs. 48.4 mIoU, 0.373 vs. 0...
Table 14, page 30 (Section 7, DINOv3 family); the 7B-scale counterpart is Table 3, page 19
ADE20k linear-probe mIoU (higher is better) and NYUv2 linear-probe depth RMSE (lower is better); single numbers, no error bars, seeds or variance reported anywhere in the paper
DINOv3 ViT-L/16 (distilled) vs. DINOv2 ViT-L/14 with registers (also SigLIP 2 and PEcore of the same size), same linear-probe protocol and hyperparameter sweep, matched patch-token count
Re-running the linear-probe protocol with the public checkpoints, DINOv3 ViT-L/16 does not beat DINOv2 ViT-L/14 (reg) by at least ~3 mIoU on ADE20k (half the reported 6.1-point gap), or its NYUv2 RMSE is not lower than DINOv2's.
table
Table 14: Comparison of our family of models against open-source alternatives of comparable size. We showcase our ViT-{S, S+, B, L, H+} models on a representative set of global and dense benchmarks: classification (IN-ReAL, IN-R, ObjectNet), retrieval (Oxford-H), segmentation (ADE20k), depth (NYU), tracking (DAVIS at 9...
https://arxiv.org/abs/2508.10104
true
https://paperswithcode.co/paper/2508.10104
2508.10552
When Language Overrules: Revealing Text Dominance in Multimodal Large Language Models
[ "Huyu Wu", "Meng Tang", "Xinhan Zheng", "Duo Su", "Haiyun Jiang" ]
poster
main
harder
Multimodal LLMs take text together with images, video, audio, time series or graphs, but are often observed to lean on the text prompt and underuse the other input. The paper measures this 'text dominance' directly from attention: during generation, how much attention per input token goes to text tokens versus non-text...
Two metrics are computed from the attention of generated output tokens to input tokens, aggregated over the generation of N output tokens and normalised so that text attention A_T plus non-text attention A_O equals 1. The Modality Dominance Index is MDI = (A_T/|T|) / (A_O/|O|), the ratio of average per-token attention ...
On MMMU-Pro, pruning 90% of LLaVA-1.5-7B's visual tokens with [CLS]-guided FasterVLM reduces late-layer MDI from 17.37 to 1.84 and middle-layer MDI from 10.23 to 1.10 (0.86 at 95% pruning), bringing text/image per-token attention close to balance (MDI = 1).
Table 2, page 7
Modality Dominance Index (closer to 1 = more balanced; > 1 = text dominance) and text Attention Efficiency Index, averaged over the first/middle/last two layers. No ± reported: no seeds, error bars or number of evaluated samples given.
LLaVA-1.5-7B with all visual tokens (0% reduction) vs. the same model with FasterVLM [CLS]-guided pruning at 75%, 90% and 95% reduction, same benchmark
Recomputing MDI as defined in Eq. 1 on MMMU-Pro, LLaVA-1.5-7B's late-layer MDI at 90% visual-token pruning stays far from 1 (e.g. above ~5) or is not substantially below the unpruned value, or the unpruned late-layer MDI is not strongly text-dominant (e.g. near 1).
table
Table 2: Effect of token-reduction ratio on Modality Dominance Index (MDI) and Attention Efficiency Index (AEI). Statistics are reported for the first two layers (Early), the middle two layers (Middle), and the final two layers (Late).
https://arxiv.org/abs/2508.10552
https://openreview.net/forum?id=qWyrRaeDAc
true
https://paperswithcode.co/paper/2508.10552
2508.13530
CrafterDojo: A Suite of Foundation Models for Building Open-Ended Embodied Agents in Crafter
[ "Junyeong Park", "Hyeonseo Cho", "Sungjin Ahn" ]
poster
evaluations_datasets
standard
Minecraft is the main testbed for open-ended embodied agents because foundation models trained on internet-scale data exist for it: VPT (behavior prior), MineCLIP (video-language grounding) and Steve-1 (instruction following). Minecraft is slow, crash-prone and hard to modify. Crafter is a lightweight 2D, pure-Python g...
A PPO-RNN expert trained for 10B steps in Craftax-Classic (symbolic) generates CrafterPlay, 20,000 pixel-observation episodes. C-VPT (ResNet + TransformerXL + policy head, VPT architecture) is behavior-cloned on CrafterPlay. A rule-based captioner (15 rules, 61 templates, each expanded with 40 LLM paraphrases) labels 6...
On the long-horizon Crafter task T4 (obtain coal -> make wood pickaxe -> obtain stone), after 1M environment steps the hierarchical PPO-Steve agent (PPO planner over C-Steve-1) reaches a success rate of about 0.6, compared with about 0.17 for PPO fine-tuning of C-VPT (C-VPT-RL), about 0 for PPO-RNN from scratch, and 0....
Figure 3, page 6
Episode success rate during training (higher is better) vs. environment steps; lines are means over 3 seeds and shaded bands are standard deviations across seeds. C-Steve-1 single-instruction is a fixed evaluation shown as a dashed line. Values are read off the plot and approximate.
PPO-Steve vs. C-VPT-RL, PPO-RNN and single-instruction C-Steve-1, all on the same tasks with the same 1M-step training budget
Retraining PPO-Steve and C-VPT-RL on T4 for 1M environment steps with 3 seeds, PPO-Steve's final success rate is not clearly above C-VPT-RL's (e.g. the gap is under ~0.2 or the seed bands overlap), or PPO-Steve does not beat single-instruction C-Steve-1 on T4.
figure
Figure 3: Training performance of four models on four long-horizon tasks. The first task requires the agents to obtain sapling, place plant, and then eat plant. The second task requires the agents to place plant and then place table. The third task requires the agents to make wood pickaxe and then obtain sapling. The l...
https://arxiv.org/abs/2508.13530
https://openreview.net/forum?id=Q7Y8eh12e2
true
https://paperswithcode.co/paper/2508.13530
2508.16007
Data Auctions for Retrieval Augmented Generation
[ "Minbiao Han", "Seyed A Esmaeili", "Michael Albert", "Haifeng Xu" ]
poster
main
harder
Data owners such as news publishers increasingly license content to generative-AI platforms for retrieval-augmented generation (RAG). The paper models a seller who auctions a database of points (documents or images) to several AI platforms, each data point going to at most one buyer. A buyer's value for a dataset is it...
LPR solves an LP relaxation with fractional allocation X̄_ij (each point's allocations sum to at most 1) and coverage C̄_ij ≤ Σ_{j' within r_ij of j} X̄_ij', then assigns each point independently to bidder i with probability X̄_ij, giving a (1 − 1/e) approximation. LPRMono adds 'data burning': bidder i receives its rou...
On CIFAR-10 embedding instances with m = 3 buyers, LPRMono runs much faster than GREEDY at every database size tested: log(runtime in seconds) is about −0.7 vs. 1.3 at n = 1000, 1.9 vs. 4.9 at n = 5000, and 4.65 vs. 8.2 at n = 20000, with non-overlapping 95% confidence bands (roughly a 20–35x speedup if the log is natu...
Figure 1, page 11
log(runtime in seconds), lower is better; curves are means over 50 random instances with 95% confidence bands; values are read off the plot and approximate; the log base is not stated
LPRMono (LP solve + randomized rounding + data burning) vs. GREEDY allocation, same CIFAR-10 instances, varying n
With reasonable implementations of both algorithms on the same CIFAR-10 instances (m = 3, n = 5000–20000), GREEDY is not clearly slower than LPRMono (e.g. less than ~5x slower, or the gap shrinks or reverses as n grows).
figure
Figure 1: Runtime in seconds of each algorithm.
https://arxiv.org/abs/2508.16007
https://openreview.net/forum?id=EtzYBT7sG8
true
https://paperswithcode.co/paper/2508.16007
2508.18741
Statistical Complexity of Soft Bellman Residual Minimization
[ "Enoch H. Kang", "Kyoungseok Jang" ]
poster
main
harder
Offline RL and inverse RL fit value functions or rewards from a fixed batch of logged transitions. Bellman residual minimization (BRM) fits a Q-function by minimizing the mean-squared Bellman error (MSBE). With entropy regularization ('soft' BRM) and a bi-conjugate reformulation, BRM becomes a min-max problem. Prior wo...
Soft BRM is written as min over Q_w, max over an auxiliary function zeta_v, of the empirical average of a per-sample saddle loss f(w, v; s, a, s') = (TD loss of Q_w) - beta^2 (V_Q(s') - zeta_v(s, a))^2 (Eq. 3-5). It is solved by minibatch SGDA (Algorithm 1): a descent step on w and an ascent step on v with dual stepsiz...
On the 5-state, 3-action soft MDP with i.i.d. data and width-16 networks, the excess population MSBE of the SGDA output decays as n^-1: the fitted log-log slope over n = 200..6400 is -1.00 (95% bootstrap interval [-1.05, -0.95]), n x excess MSBE stays between 0.385 and 0.443, and every width and data regime has a slope...
Table 6, page 28 (Appendix E); also Figure 1, page 10
n x excess population MSBE (mean +/- standard error over 50 repetitions) and the fitted slope of log(excess MSBE) vs log n over n >= 200, with a 95% bootstrap interval over repetitions
Observed decay rate of the SGDA output's excess MSBE vs the theorem's predicted n^-1 rate and the n^-1/2 rate of prior bounds, across widths H = 8/16/32, i.i.d. vs single-trajectory data, and against the exact empirical minimizer
Rerunning the stated setup gives a fitted slope (n >= 200) whose 95% bootstrap interval excludes -1 or includes -1/2 for H = 16 i.i.d. data, or n x excess MSBE grows steadily with n (for example, a clear upward trend from 0.44 at n = 200 to well above 1 at n = 6400).
table
Table 6: n times the excess population MSBE of the SGDA output (mean ± standard error), and of the exact empirical minimizer on the datasets of the i.i.d. H = 16 runs.
https://arxiv.org/abs/2508.18741
https://openreview.net/forum?id=QJrpoS9mBV
true
https://paperswithcode.co/paper/2508.18741
2508.21380
The Algorithm Is Not the Behavior: Learned Priors Override Look-Ahead in a Chess-Playing Neural Network
[ "Elias Sandmann", "Sebastian Lapuschkin", "Wojciech Samek" ]
oral
main
standard
Mechanistic interpretability work has found learned algorithms inside networks, including look-ahead in Leela Chess Zero's policy network (Jenner et al., 2024). Those studies show the algorithms exist and matter when the model succeeds. This paper asks whether a learned algorithm actually determines the output. It repo...
The network is Leela Chess Zero T82-768x15x24h (15-layer Post-LN encoder transformer, one token per square), used as a policy network without search. Puzzles are the 10,000-puzzle Lichess set from Ruoss et al. (2024); a puzzle counts as solved if argmax move selection reproduces all of the player's principal-variation ...
Steering Leela's residual stream after layer 13 against the 'opponent threats' safety concept raises the held-out puzzle solve rate to 92.43 ± 0.25%, vs. 88.6% unsteered and about 89% for random directions under the same protocol; the fixed setting (alpha = -0.5) recovers 71.7% of the 8,595 held-out forgotten puzzles.
Figure 6 (right), page 8; exact values in Section 3.3 and Appendix O, page 84
Held-out puzzle solve rate (%) on the 10,000 Lichess puzzles (full principal variation correct), higher is better; ± is std over 200 random half/half cross-validation splits, not over seeds. Random baseline: mean of 50 random unit vectors, 95% CI across vectors.
Opponent-threats gradient steering at layer 13 vs. the unsteered model and vs. random-direction steering with the same strength selection protocol
With the released network and puzzle set, layer-13 opponent-threats steering (strength chosen on held-out halves) does not exceed the random-direction baseline at layer 13 by more than about 1 point, or the fixed alpha = -0.5 setting recovers well under half of the forgotten-puzzle set.
figure
Figure 6: Safety-related concept analysis across layers. Left: Mean concept preference Delta c_l for four safety-related concepts, measured in centipawns with 95% CI. Late layers shift from aggressive toward conservative concept preferences. Right: Held-out solve rate when steering with each concept's gradient, with th...
https://arxiv.org/abs/2508.21380
https://openreview.net/forum?id=ULhusDnCQy
true
https://paperswithcode.co/paper/2508.21380
2509.11311
Prompts to Proxies: Emulating Human Preferences via a Compact LLM Ensemble
[ "Bingchen Wang", "Zi-Yu Khoo", "Jingtan Wang" ]
poster
main
standard
LLMs are increasingly used as stand-ins for human survey respondents, but off-the-shelf models collapse toward central tendencies, and demographic-conditioning approaches need individual profiles and still do not reliably match population response distributions. The paper asks whether aggregate survey response distribu...
Each survey's questions are split 7:1.5:1.5 into train/validation/test. Stage 1 (active endowment generation) builds a pool of up to 300 proxy agents with Gemini-2.0-flash: profiles ('endowments') are generated from an attribute bank organized into modes, plus survey- and question-specific attributes extracted by an LL...
On 14 ATP waves with a 300-agent budget and identical lasso aggregation, P2P's held-out test MSE averages 0.014 versus 0.025 for Vanilla and 0.029 for PERSONA, and is lower than both baselines on every wave (e.g. W42: 0.011 ± 0.000 vs. 0.029 ± 0.005 and 0.036 ± 0.001; W82: 0.008 ± 0.002 vs. 0.021 ± 0.004 and 0.021 ± 0....
Table 3 (Appendix D.1), page 34; means also in Table 1, page 8
Test MSE of option-level response proportions on held-out questions (lower is better); mean over 3 runs with sample SD in parentheses. 1-JSD (higher better) and EMD (lower better) also reported.
P2P (entropy-guided attribute-based endowment generation) vs. Vanilla and PERSONA endowment pools, all with 300 agents, Gemini-2.0-flash, and the same constrained-lasso Stage 2
With matched budget, backbone and Stage 2, P2P's average test MSE over the 14 waves is not clearly below the best baseline's (e.g. the gap is within run-to-run SD), or P2P fails to beat the best baseline beyond SD on most individual waves such as W42 and W82.
table
Table 3: Full distribution metrics comparison across 14 ATP waves. MSE measures mean squared error of predicted response probabilities. 1-JSD (1 minus Jensen-Shannon Divergence) measures distributional similarity (higher is better). EMD (Earth Mover's Distance) measures distributional distance (lower is better). Each c...
https://arxiv.org/abs/2509.11311
https://openreview.net/forum?id=rSe48IgBEz
true
https://paperswithcode.co/paper/2509.11311
2509.15543
Nonconvex Decentralized Stochastic Bilevel Optimization under Heavy-Tailed Noise
[ "Xinwen Zhang", "Yihan Zhang", "Heng Liang", "Hongchang Gao" ]
poster
main
harder
Bilevel optimization (an outer problem whose objective depends on the solution of an inner problem) underlies hyperparameter optimization, meta-learning and model pruning. Decentralized versions let workers holding local data solve it by peer-to-peer communication. Existing decentralized bilevel methods assume a strong...
The bilevel problem with a nonconvex (PL) inner objective is rewritten via a penalty as a minimax problem min_{x,y} max_z f(x,y) + (1/delta)(g(x,y) - g(x,z)). D-NSVRGDA (Algorithm 1) has each worker keep STORM-style variance-reduced estimates of the gradients with respect to x, y and z, combine them with gradient track...
On Synthetic Dataset I with Cauchy label noise, after 15,000 iterations D-NSVRGDA reaches an upper-level loss of about 0.02-0.04 for all three noise levels (alpha = 0.2, 0.1, 0.05), roughly a third of the un-normalized ablation D-SVRGDA (about 0.09-0.12) and below every clipped variant and D-F2BSA baseline (best about ...
Figure 1 (a)-(f), page 7
upper-level (validation) loss vs. iteration, lower is better; test accuracy vs. iteration; single run per curve, no error bars
D-NSVRGDA vs. D-SVRGDA (same algorithm without normalization), D-SVRGDA-Clip (tau = 0.8, 0.6, 0.5, 0.2), D-F2BSA-VR and D-F2BSA-1/5/10, all with the same data, graph, batch size and learning rate
Over several seeds, D-NSVRGDA's upper-level loss at 15,000 iterations is not clearly below D-SVRGDA's (e.g. the gap is within seed-to-seed spread) at any of the three noise levels.
figure
Figure 1: The upper-level loss function value and test accuracy on different datasets that are generated with different levels of heavy-tailed noise.
https://arxiv.org/abs/2509.15543
https://openreview.net/forum?id=15yIjsQCrh
true
https://paperswithcode.co/paper/2509.15543
2509.21172
Inverse Reinforcement Learning with Just Classification and a Few Regressions
[ "Lars van der Laan", "Nathan Kallus", "Aurelien Bibaut" ]
poster
main
standard
Inverse reinforcement learning (IRL) tries to recover a reward function from observed behaviour. In the maximum-entropy (Gumbel-shock dynamic discrete choice) model, the behaviour policy identifies the reward only up to potential-based shaping, so recovering a specific reward requires a normalization. DeepPQR (Geng et ...
GenPQR handles any statewise affine normalization Σ_a µ(a|s) r(s,a) = g(s). Step 1 estimates the behaviour policy and sets û = log π̂(a|s) (any classifier, behaviour cloning, or AIRL). Step 2 solves the linear Bellman equation Q(s,a) = û(s,a) − g(s) + γ E_{s'~P, a'~µ}[Q(s',a')] by fitted Q-evaluation over all observed ...
With the same AIRL policy estimate and neural FQE, GenPQR recovers the anchor-normalized reward with much lower MSE than DeepPQR when the anchor action is rare (16% of transitions): 0.91 ± 0.11 vs. 2.60 ± 0.15 with 200 training trajectories, and 0.76 ± 0.08 vs. 1.48 ± 0.10 with 1000. With a common anchor (2500 trajecto...
Figure 1 (table with inset plot), page 12
Reward mean squared error against the ground-truth normalized reward (lower is better); also reward correlation (higher is better). ± is the half-width of a normal-approximation 95% confidence interval over 100 seeds.
GenPQR vs. DeepPQR, both using the same AIRL behaviour-policy estimate and neural FQE, in three (trajectory count, anchor frequency) regimes
In the rare-anchor regimes (200 or 1000 trajectories, anchor logit shift −1.0), GenPQR's mean reward MSE is not clearly below DeepPQR's: the 95% CIs overlap, or the ratio DeepPQR/GenPQR is below about 1.5 at 200 trajectories.
table
Figure 1: Matched DeepPQR vs. GenPQR comparison. Both use the same AIRL policy estimate and neural FQE. Entries are mean ± 95% CI over 100 seeds. Anchor count is the number of anchor-action transitions used by DeepPQR's anchor-Q step.
https://arxiv.org/abs/2509.21172
https://openreview.net/forum?id=rZaXY04Gvf
true
https://paperswithcode.co/paper/2509.21172
2509.22738
Enabling approximate joint sampling in diffusion LMs
[ "Parikshit Bansal", "Sujay Sanghavi" ]
poster
main
harder
Masked diffusion language models such as Dream-7B and LLaDA-7B generate text by repeatedly unmasking tokens. Each forward pass gives only per-position marginal distributions, so unmasking several tokens in one pass samples them independently from the product of their marginals rather than from the joint distribution th...
ADJUST is a single transformer decoder layer (about 200M parameters, same layer architecture as the base model) placed on top of a frozen base diffusion LM. In each denoising step the base model runs once to give hidden states h0 = f(x); the first token is sampled from the base model's marginals at the position chosen ...
For unconditional 128-token generation from Dream-7B-Base at temperature 1.0 with K = 4 tokens unmasked per step, ADJUST samples reach MAUVE 0.87 against the model's K = 1 (true joint) samples, vs. 0.31 for naive parallel sampling and 0.39 for EDLM, and lower Qwen-2.5-7B NLL (5.58 vs. 6.52 and 6.18); the gap persists a...
Table 1, page 7 (all K from 1 to 8 in Table 4, Appendix C.1, page 12)
MAUVE (GPT2-Large features) between generated strings and the base model's K = 1 samples, higher is better; generative NLL under Qwen-2.5-7B, lower is better. Single numbers, no error bars, seeds or sample counts reported (the checklist says standard errors are small but omitted).
ADJUST vs. naive parallel sampling and EDLM (two candidate completions, pick the lower Qwen-2.5-0.5B perplexity) on the same frozen Dream-7B-Base, same number of tokens per step K, same temperature and the base model's unmasking rule
With Dream-7B-Base, T = 1.0, K = 4, an ADJUST layer trained as described does not reach MAUVE (vs. K = 1 samples) at least ~0.3 higher than naive parallel sampling under the same evaluation, e.g. ADJUST MAUVE below ~0.6 while parallel is ~0.3.
table
Table 1: Unconditional Generation. In this table we compare the NLL and the MAUVE scores for three different methods : Marginal, Joint and Energy-based (EDLM). The base diffusion model is Dream-Base-7B. Across different number of tokens K sampled per step, and different sampling temperature, joint sampling consistently...
https://arxiv.org/abs/2509.22738
https://openreview.net/forum?id=qFl5qT3qAP
true
https://paperswithcode.co/paper/2509.22738
2509.22818
Can Large Language Models Develop Gambling Addiction?
[ "Seungpil Lee", "Donghyeon Shin", "Yunjeong Lee", "Sundong Kim" ]
poster
main
standard
LLMs are increasingly deployed as agents that make sequential financial decisions, but it is unclear under what conditions they drift into self-defeating risk-taking. The paper borrows constructs from clinical research on pathological gambling (loss of bet-size control, loss chasing, goals that turn into moving targets...
Six LLMs (GPT-4o-mini, GPT-4.1-mini, Gemini-2.5-Flash, Claude-3.5-Haiku, LLaMA-3.1-8B-Instruct, Gemma-2-9B-IT) play a text slot machine with a 30% win rate and a 3x payout (each round loses 10% of the bet in expectation), starting from $100. Each round the model is shown its balance and the game history and chooses to ...
In the slot-machine task, every one of six LLMs goes bankrupt more often under variable betting than under fixed $10 betting (1,600 games per arm), e.g. LLaMA-3.1-8B 0.4% -> 72.3%, Gemini-2.5-Flash 3.1% -> 48.1%, GPT-4o-mini 0.0% -> 21.3%, with the smallest gap on Gemma-2-9B (0.0% -> 5.4%).
Table 17, page 25 (same numbers as Figure 2a, page 3, and Table 7, page 16; differences with CIs in Table 8, page 16)
Bankruptcy rate (% of games ending at $0; higher = riskier), pooled over 32 prompt conditions x 50 games; brackets are 95% Wilson intervals over games. Table 8 gives variable-minus-fixed differences with Newcombe intervals (e.g. LLaMA +71.9 [+69.6, +74.0] pp, Gemma +5.4 [+4.4, +6.7] pp).
Variable betting ($5 up to balance, model chooses) vs. fixed $10 betting, same model, same prompts, same game, per model.
For a rerun model (e.g. LLaMA-3.1-8B-Instruct or GPT-4o-mini) over the 32 prompt conditions, the variable-arm bankruptcy rate is not clearly above the fixed-arm rate (95% intervals overlap), or for LLaMA-3.1-8B the variable-arm rate falls far outside the reported ~70-74% range.
table
Table 17: Participation, realised bet size and re-betting after a first loss beside the bankruptcy rate of every primary slot-machine cell (Figure 2a), n = 1,600 games per cell. Bankruptcy, participation and re-betting carry 95% Wilson intervals. The mean wager carries a 95% bootstrap interval over whole games. Definit...
https://arxiv.org/abs/2509.22818
https://openreview.net/forum?id=sNiZd9EAPW
true
https://paperswithcode.co/paper/2509.22818
2509.23355
Uncertainty Estimation for Pretrained Medical Image Registration Models via Transformation Equivariance
[ "Lin Tian", "Xiaoling Hu", "Juan Eugenio Iglesias" ]
poster
main
harder
Deep learning registration networks predict a dense deformation field between two medical images but give no indication of where that prediction is unreliable, so misregistrations can silently corrupt downstream measurements. Existing uncertainty methods for registration (variational inference, MC-dropout, ensembles) r...
Given a frozen registration network f, source image I_A and target I_B, the method samples N = 50 random spatial perturbations tau of the source (translation up to 1% of image size, scale U(0.9,1.1), shear U(-0.02,0.02), or B-spline deformation with 10-px grid and displacement U(-12.5,12.5) px), runs g_n = tau_n o f(I_...
With pretrained uniGradICON on Learn2Reg Abdomen CT, the translation-perturbation uncertainty map has dataset-mean Pearson correlation with true voxel-wise registration error of about 0.70 (translation GT), 0.71 (affine GT), 0.64 (ANTs-derived real GT) and 0.39 (B-spline deformation GT); correlation is positive in all ...
Figure 5, page 7
Pearson r and Spearman rho between uncertainty map and voxel-wise L2 registration error within ROI, averaged over the dataset (higher is better); mean AURC vs. mean mError (lower AURC than mError means better-than-random ranking). No error bars, seeds or CIs are reported.
Correlation of the proposed uncertainty map with true error across 4 ground-truth transformation types x 4 perturbation types x 2 datasets; AURC compared to the random-ranking baseline (mean mError). No competing uncertainty method is compared on this task.
On Learn2Reg Abdomen CT with uniGradICON, the translation-perturbation uncertainty map gives dataset-mean Pearson r clearly below ~0.5 under translation or affine ground truth (e.g. r < 0.4), or non-positive correlation in any setting, or AURC not below the mean error.
figure
Figure 5. Correlation between the estimated uncertainty and the true registration error for a combination of varying ground truth transformation types (GT), perturbation transformation types, and datasets with uniGradICON.
https://arxiv.org/abs/2509.23355
https://openreview.net/forum?id=vcFcWZeEEC
true
https://paperswithcode.co/paper/2509.23355
2509.23410
PATCH: Learnable Tile-Level Hybrid Sparsity for LLMs
[ "Mohammad Mozaffari", "Younes Hourri", "Maryam Mehri Dehnavi" ]
poster
main
harder
Pruning cuts the memory and compute cost of LLMs, but the two common options pull in different directions. Unstructured sparsity keeps accuracy but cannot be accelerated on GPUs. NVIDIA/AMD 2:4 semi-structured sparsity is hardware-accelerated but forces exactly 50% sparsity in every layer, which hurts quality even when...
PATCH splits every weight matrix into 128x128 tiles and marks each tile as either dense or 2:4 sparse. Each tile has one learnable logit, sampled with Gumbel-Softmax to give a soft tile mask M_tile. This is merged with a MaskLLM-style differentiable 2:4 mask M_2:4 (a learnable categorical over the six 2:4 patterns per ...
On Qwen-2.5 0.5B, LLaMA-3.2 1B and Gemma-3 1B, PATCH-Joint at 45% global sparsity gets lower WikiText2 perplexity and higher eight-task average accuracy than 50% 2:4 MaskLLM: PPL 14.57 vs 15.22, 12.23 vs 12.93 and 11.96 vs 12.82; accuracy 40.29 vs 39.33, 42.08 vs 41.04 and 42.80 vs 41.84.
Table 1, page 6
WikiText2 perplexity (lower is better, seq len 4096) and average zero-shot accuracy over 8 tasks (higher is better). Table 1 is a single run with no error bars. Appendix J (Table 20) reports PATCH perplexity over 4 seeds: Qwen-2.5 0.5B at 45% gives 14.49-14.61 and LLaMA-3.2 1B at 45% gives 12.23-12.55. No seed variatio...
PATCH-Joint (Dense/2:4 tiles, 45% global sparsity) vs. MaskLLM (learned 2:4, 50% sparsity), the strongest baseline. Both learn masks end-to-end on SlimPajama with frozen weights.
With masks trained under the paper's setup, PATCH-Joint at 45% fails to beat MaskLLM 2:4 on WikiText2 perplexity by more than the seed spread (about 0.1-0.3 PPL) on these models, or its eight-task average accuracy is not higher than MaskLLM's.
table
Table 1: Model quality (average accuracy across eight zero-shot tasks and perplexity on WikiText2 dataset) for different pruning methods. By jointly optimizing the location of dense tiles and the sparsity pattern within the sparse tiles, PATCHJoint allows for a continuous sparsity ratio for the models, providing a flex...
https://arxiv.org/abs/2509.23410
https://openreview.net/forum?id=ABuaxVr804
true
https://paperswithcode.co/paper/2509.23410
2509.23765
Knowledge-Level Consistency Reinforcement Learning: Dual-Fact Alignment for Long-Form Factuality
[ "Junliang Li", "Yucheng Wang", "Yan Chen", "Yu Ran", "Ruiqing Zhang", "Jing Liu", "Hua Wu", "Haifeng Wang" ]
poster
main
harder
LLMs hallucinate in long-form answers, and RLHF preference rewards do not account for what the model actually knows. Earlier factuality-alignment methods score responses with retrieval-based checkers such as FActScore. These checkers are too slow for online RL, and because they reward precision alone, models learn to s...
Offline, the base model (Qwen2.5-14B) is sampled 8 times per training query (ELI5, LongFact-Gen and LongWiki-Gen; about 13K queries). Atomic claims are extracted, and each is verified against a local Wikipedia index (Wiki20250716, top-10 retrieval) by Qwen2.5-72B-Instruct. SUPPORT claims, after deduplication and import...
Starting from the Qwen2.5-14B base model, GRPO with the KLC rewards (KLCF-zero) beats GRPO with a FActScore reward on FActScore (61.2% vs. 54.8%) and on LongFact-Objects F1@64 (0.733 vs. 0.663, recall@64 0.776 vs. 0.634), without losing precision (0.704 vs. 0.690).
Table 1, page 8
FActScore (% supported atomic facts, higher is better) and VeriScore-style Recall@64 / Precision / F1@64 on LongFact-Objects (higher is better). These are single-run point estimates, averaged over test prompts. No seeds, std or confidence intervals are reported.
Qwen2.5-14B + GRPO with KLC rewards (KLCF-zero) vs. Qwen2.5-14B + GRPO with FActScore reward, both trained from the same base model. Base (10-shot), CoVe and Self-Eval-P(True) are also listed.
Using the paper's evaluation pipeline, KLCF-zero's FActScore lead over GRPO&FActScore shrinks below about 2 points, its LongFact F1@64 lead shrinks below about 0.02, or KLCF-zero's LongFact precision falls clearly below the FActScore-reward model. Any of these would refute the claim. So would retraining with a differen...
table
Table 1: Results on Qwen2.5-14B. SFT denotes the DeepSeek-R1-Distill-Qwen-14B. R@32 and Prec are Recall@32 and Precision. Best scores are bolded.
https://arxiv.org/abs/2509.23765
https://openreview.net/forum?id=OsM0q9Qc8R
true
https://paperswithcode.co/paper/2509.23765
2509.25783
Sharpness of Minima in Deep Matrix Factorization
[ "Anıl Kamber", "Rahul Parhi" ]
spotlight
main
harder
For gradient descent with step size η, a minimum is linearly (dynamically) stable only if the largest eigenvalue of the loss Hessian there, λmax, is at most 2/η. So λmax ('sharpness') decides which minima GD can settle in, and it is central to work on implicit bias, flat minima and edge-of-stability. For deep matrix fa...
The loss is L(w) = ||M − W_L ··· W_1||_F^2 with all layer widths at least min(d_0, d_L). Theorem 3.1 states that at any global minimizer w* (M = W_L* ··· W_1*), λmax(∇²L(w*)) = 2 σmax( Σ_{i=1}^{L} (B_i^T B_i) ⊗ (A_i A_i^T) ), where A_k = W_L* ··· W_{k+1}* and B_k = W_{k-1}* ··· W_1* (empty products are the identity). S...
For a depth-3 Gaussian factorization of a 10×20 matrix, with GD started 1e-12 from the minimizer along the top Hessian eigenvector, GD with η = 2/λmax (λmax from Theorem 3.1) stays at the minimizer for 2000 iterations. With η = 1.01×2/λmax and 1.02×2/λmax, GD escapes after about 1250 and 650 iterations: the loss spikes...
Figure 1, page 10 (also Figures 2–5, pages 22–23)
Normalized squared distance ||w_t − w*||_2^2/||w*||_2^2 after T = 2000 iterations, plus the normalized training loss L(w_t)/||M||_F^2. Escape means the final distance is far above the initial ~1e-24 scale. One random instance; no ± is reported.
GD at step sizes just below/at 2/λmax vs. just above 2/λmax, where λmax is the paper's closed form (Theorem 3.1). The implicit check is that the closed form equals the true top Hessian eigenvalue, so the stability threshold lands exactly at η = 2/λmax.
Refuted if the closed-form λmax differs from the top eigenvalue of the numerically computed Hessian at w* (beyond floating-point error) for random minimizers, or if GD at η = 2/λmax × 1.01 (started along v_1 at r = 1e-12) does not leave w* while η ≤ 2/λmax does, i.e., the observed stability threshold is not at 2/λmax.
figure
Figure 1: The setting is a depth-3 matrix factorization of a random 10 × 20 matrix with Gaussian factors W3 ∈ R^{10×20} and W1, W2 ∈ R^{20×20}. v1 and vN are the eigenvectors of ∇²L(w*) that correspond to its maximum and minimum eigenvalues respectively. λmax is computed via the closed-form expression in Theorem 3.1. G...
https://arxiv.org/abs/2509.25783
https://openreview.net/forum?id=tin36Zr1Ue
true
https://paperswithcode.co/paper/2509.25783
2510.00225
TGPO: Temporal Grounded Policy Optimization for Signal Temporal Logic Tasks
[ "Yue Meng", "Fei Chen", "Chuchu Fan" ]
poster
main
standard
Signal Temporal Logic (STL) specifies robot tasks with timed reach, stay and avoid requirements (e.g. 'reach A within [0,50], stay in C during [60,80], always avoid obstacles'). Solving STL with model-free RL is hard because satisfaction depends on the whole trajectory (non-Markovian) and the natural reward, the STL ro...
TGPO flattens an STL formula into subgoals (Reach(mu, tau) or Inv(mu, W)) and invariant avoid constraints whose times depend on a few integer time variables (e.g. the instant tau in F[a,b]). Given a concrete assignment of the time variables, the subgoals become an ordered sequence. The state is augmented with the time ...
In the Linear environment (10 STL tasks, T = 100), full TGPO* reaches 88.99 ± 9.60% test success, while the same method trained only on the STL robustness reward reaches 11.73 ± 2.67% and the method without state augmentation (no time index, no flags) reaches 11.43 ± 3.48%; adding the distance reward term alone lifts s...
Table 1b, page 8
Test STL task success rate (%) over 512 initial states and 10 STL tasks, higher is better; ± is std over 7 random seeds
TGPO* with full augmented state and full dense reward vs. the same pipeline with (i) robustness-only reward, (ii) partial reward terms, (iii) no flags, (iv) no flags and no time index
Re-running the Linear-environment ablation with several seeds, full TGPO* success is not clearly above the robustness-only-reward variant and the no-augmentation variant (e.g. the gap is under ~30 points or within one seed std), or adding the distance term to STL+Inv does not raise success by well over one std.
table
Table 1: Ablation studies for TGPO on the linear dynamics environment. (a) Different time variables sampling strategies. (b) Different state augmentation and rewards.
https://arxiv.org/abs/2510.00225
https://openreview.net/forum?id=uhy1JdsQsE
true
https://paperswithcode.co/paper/2510.00225
2510.01137
Re-examining Low Rank adaptation for private LLM fine-tuning
[ "Ali Dadsetan", "Frank Rudzicz" ]
poster
main
standard
DP-SGD makes fine-tuning differentially private by clipping per-example gradients and adding isotropic Gaussian noise, and this noise slows convergence. Fewer training steps at a fixed noise level also means less privacy budget spent. Gradients of transformer linear layers are close to low-rank, so their singular value...
At each DP-SGD step, after the noisy averaged gradient is formed, the gradient of every linear layer (here the LoRA factors) is treated as a noisy low-rank matrix with known noise std sigma = sigma_DP * C / |B|. The layer gradient is denoised with the Shabalin-Nobel optimal singular-value shrinkage estimator (Eqs. 8-9)...
On QNLI with RoBERTa-base under DP-LoRA (epsilon = 6.7 over 400 steps), adding the spectral denoiser raises validation accuracy from 50.3 ± 2.3 to 78.2 ± 1.3 at step 200 and from 80.7 ± 0.9 to 84.4 ± 0.3 at step 400.
Table 1, page 8
Validation accuracy (%), higher is better; mean over 5 runs ± half-width of the 95% t-confidence interval of the mean
DP-LoRA + per-layer RMT singular-value denoising vs. standard DP-LoRA, same hyperparameters, noise multiplier and privacy budget
Over 5 matched runs on QNLI with RoBERTa-base, the denoised run's mean accuracy at step 400 is not above the DP-LoRA mean, or the 95% CIs overlap. At step 200, the denoised run fails to beat DP-LoRA by a margin outside the CIs.
table
Table 1: Comparison of our SVD denoising method with standard DP-LoRA on GLUE classification tasks. We report mean accuracy across runs ± the half-width of the 95% confidence interval, computed from the standard error over runs (Appendix H). Step speedup and ∆ϵ (privacy budget saved) represent the percentage of iterati...
https://arxiv.org/abs/2510.01137
https://openreview.net/forum?id=Phmae0oHes
true
https://paperswithcode.co/paper/2510.01137
2510.02425
Words That Make Language Models Perceive
[ "Sophie L. Wang", "Phillip Isola", "Brian Cheung" ]
poster
main
standard
Text-only LLMs have never seen images or heard sounds, yet earlier work (the Platonic Representation Hypothesis) found that their embeddings of captions have a neighbourhood structure partly similar to that of vision encoders run on the paired images. That work measured alignment from single forward passes, so alignmen...
Each caption c is wrapped in a prompt template: no cue 'Imagine: {caption}.', SEE cue 'Imagine what it would look like to see {caption}.', or HEAR cue 'Imagine what it would sound like to hear {caption}.'. A frozen Qwen3-32B generates a 128-token continuation. The generative representation z_g is the hidden state avera...
With Qwen3-32B generative representations (128 tokens) on WiT, the SEE-cue prompt raises mutual-kNN alignment with DINOv2 from about 0.137 (no cue) to about 0.155, while the HEAR cue leaves it at about 0.136; with single-pass embeddings, the SEE cue does not help (about 0.113 vs 0.122 for no cue).
Figure 3a, page 4
Mutual-kNN alignment between LLM caption kernel and DINOv2 image kernel (higher is better); error bars and shaded band are ±1 bootstrap standard error over resampled paired rows (B = 1000), about ±0.005. Values are read off the plot and approximate. No seed variation over generations is reported.
SEE cue vs. no-cue (and HEAR cue) prompt for Qwen3-32B generative representations z_g, same captions, same encoder; secondary contrast with single-pass embeddings z_e
On WiT with Qwen3-32B 128-token generations, SEE-cue z_g alignment with DINOv2 is not higher than no-cue z_g alignment by more than about 2 bootstrap SEs (e.g. gain < 0.01), or the HEAR cue matches or beats the SEE cue on DINOv2.
figure
Figure 3: Sensory cues induce a generative text-only LLM representation that has higher alignment with the corresponding encoder. The star denotes matching cue-modality in generative representation. (a) Sensory cued alignment using single-pass embedding (z_e) and generative (z_g) representations. (b) Prompt templates u...
https://arxiv.org/abs/2510.02425
https://openreview.net/forum?id=6R1lPBxpMO
true
https://paperswithcode.co/paper/2510.02425
2510.03016
DELTA: Robustly Training Label-Conditional Diffusion Models with Weak Annotations
[ "Dong-Dong Wu", "Jiacheng Cui", "Wei Wang", "Zhiqiang Shen", "Masashi Sugiyama" ]
poster
main
standard
Label-conditional diffusion models are trained on (image, class label) pairs and assume the labels are clean. In practice labels are often noisy (wrong), ambiguous (a candidate set that contains the true class), or missing for most of the data. Training a conditional diffusion model directly on such weak annotations pr...
DELTA treats the true label as a latent variable and trains with an EM-style objective. In the generative term, the network's conditional score outputs for all classes are mixed with weights equal to the estimated posterior p(y | x_t, z) given the weak annotation z, and this mixture is regressed onto the standard denoi...
On CIFAR-10 with random ambiguous labels (each wrong class added to the candidate set with probability 0.5), DELTA reaches CW-FID 10.65 and FID 2.26, versus 27.18 and 7.76 for the Vanilla ablation trained identically without posterior-weighted score matching (clean-label upper bound: 9.83 and 2.05).
Table 1, page 6
Class-wise FID (CW-FID, intra-class FID averaged over the 10 classes) and unconditional FID, lower is better; single runs, no error bars reported
DELTA vs. Vanilla (same architecture, data, weak labels and 200k-iteration budget; only the generative term differs), with a model trained on clean labels as reference
Training both models on CIFAR-10 with random ambiguous labels (q = 0.5) under the same budget, DELTA's CW-FID is not clearly below Vanilla's (e.g. less than about 1.5x lower, or the gap is within the spread of a few seeds), or DELTA's FID is not clearly below Vanilla's.
table
Table 1: Generative results under various weak annotations. The gray-shaded 'Clean' column represents the best performance trained on the fully clean dataset. 'uncond'/'cond' denote unconditional/conditional metrics. Bold numbers indicate better performance.
https://arxiv.org/abs/2510.03016
https://openreview.net/forum?id=1fJGfUpQRC
true
https://paperswithcode.co/paper/2510.03016
2510.03224
Test-Time Defense Against Adversarial Attacks via Stochastic Resonance of Latent Ensembles
[ "DONG LAO", "Yuxiang Zhang", "Haniyeh E Oskouie", "Yangchao Wu", "Alex Wong", "Stefano Soatto" ]
poster
main
harder
Neural network classifiers and dense predictors can be pushed to wrong outputs by small, imperceptible adversarial input perturbations. Most defenses either retrain the model (adversarial training) or filter/smooth inputs or features with a fixed scheme, which loses information and can be bypassed by adaptive attackers...
Stochastic resonance (SR) applies a set of small integer-pixel translations g_{u,v} with |u| <= d, |v| <= d (N = (2d+1)^2 shifted copies) to the input image, runs each copy through the network up to a chosen layer, shifts each resulting feature map back by the inverse translation (A_g), and averages the aligned feature...
On CIFAR-10 with the AT ResNet-18 checkpoint, adding test-time stochastic resonance raises PGD-20 (eps=8/255) robust accuracy from 48.22% to 56.08% against a non-adaptive attacker and to 53.58% against a fully adaptive attacker that differentiates through all SR passes, while clean accuracy stays at 84.93% vs 85.02%; n...
Table 1, page 5
Top-1 accuracy (%) on the CIFAR-10 test set under l_inf attacks with eps = 8/255, higher is better; single run, no error bars or seeds reported
AT ResNet-18 + SR (non-adaptive and worst-case adaptive attack) vs. the same AT ResNet-18 without defense, and vs. AT + FD / CAS / CIFS / FSR / TTE
Under an adaptive PGD-20 attack (eps=8/255) that backpropagates through the full SR ensemble (e.g. full white-box gradients, or EOT/BPDA if gradients are obfuscated), the SR-defended AT ResNet-18 scores no more than about 2 points above the undefended AT model's 48.22%, or its clean accuracy drops by more than about 1 ...
table
Table 1: Defense against adversarial attacks on CIFAR-10. Unlike baselines, we perform defense purely at test-time, and achieve state-of-the-art robustness under different attacks. Even in an adaptive setting (worst-case) where the attacker is fully aware of how defense is applied, the effectiveness of adversarial atta...
https://arxiv.org/abs/2510.03224
https://openreview.net/forum?id=RNQOTYbTSv
true
https://paperswithcode.co/paper/2510.03224
2510.03352
Inference-Time Search Using Side Information for Diffusion-Based Image Reconstruction
[ "Mahdi Farahbakhsh", "Vishnu Teja Kunde", "Dileep Kalathil", "Krishna Narayanan", "JF Chamberland" ]
poster
main
standard
Diffusion models are widely used as priors for inverse problems such as inpainting, super-resolution and deblurring. When the measurement is badly degraded, many reconstructions fit it equally well, and posterior sampling rarely recovers the true image. Side information, such as another photo of the same person, a text...
The paper treats the posterior given side information s as the unconditional diffusion prior tilted by exp(r(x0; s)/τ), where r is an off-the-shelf reward that scores how consistent a reconstruction is with s. The reward is never differentiated. Instead, N particles of a standard solver (DPS, DAPS or MPGD) are run in p...
On CelebA-HQ 96×96 box inpainting with DAPS as the base solver and a reference image of the same identity as side information, RFJS (N=8, B=4) reaches a FaceSimilarity distance to ground truth of 0.423 ± 0.10, against 0.739 ± 0.18 for plain DAPS and 0.611 ± 0.14 for Best-of-8 with the same reward. PSNR, LPIPS and SSIM ...
Table 6, page 23 (Appendix C.3)
FaceSimilarity (AdaFace identity-embedding distance between reconstruction and ground truth, lower is better); PSNR, LPIPS and SSIM are secondary. ± is the per-image standard deviation across the test images (not seeds); the number of test images is not stated.
DAPS + RFJS vs. plain DAPS (primary), and vs. DAPS + Best-of-N, Greedy Search and reward-gradient guidance with the same AdaFace reward
With the stated setup (DAPS, 96×96 box inpainting, N=8, B=4, AdaFace reward on a different image of the same identity), mean FaceSimilarity for RFJS is not lower than plain DAPS by clearly more than the per-image std (e.g. the gap is under about 0.15, versus the reported 0.316), or RFJS does not beat Best-of-8 with the...
table
Table 6: Comparison of metrics for various inverse problems using DAPS as the base sampler. For each metric, the best result is shown in bold, and the second best is underlined. We observe that our RFJ Search-based algorithm has the best or the second-best performance in all the tasks.
https://arxiv.org/abs/2510.03352
https://openreview.net/forum?id=ySeae740Om
true
https://paperswithcode.co/paper/2510.03352
2510.03614
Neural Bayesian Filtering
[ "Christopher Solinas", "Radovan Haluška", "David Sychrovský", "Finbarr Timbers", "Nolan Bard", "Michael Buro", "Martin Schmid", "Nathan Sturtevant", "Michael Bowling" ]
poster
main
standard
Bayesian filtering tracks the posterior over a hidden state as noisy observations arrive. Gaussian filters such as the ensemble Kalman filter (EnKF) scale to high dimensions but cannot represent non-Gaussian or multimodal beliefs. Particle filters can represent any distribution, but in high dimensions their weights col...
Neural Bayesian Filtering (NBF) represents the belief as an embedding θ from a Generative Distribution Embedding: a Set Transformer encoder (three rounds of Induced Set Attention Blocks with pooling) maps a weighted particle set to θ, and a conditional flow-matching generator samples states given θ. Each filter step dr...
On Lorenz-96 with K = 40 at the held-out forcing F = 8 (σ_obs = 1), NBF with 1024 particles reaches RMSE 1.060 and NLL 53.6. The localized EnKF(100) reaches RMSE 1.506 and NLL 63.1, and the regularized particle filter with 131,072 particles reaches RMSE 4.332 (SEMs ≤ 0.03 RMSE, ≤ 0.2 nats NLL).
Table 1, page 7 (full budgets in Table 12, page 24)
RMSE of the posterior mean against the true state (lower is better), plus NLL of the true state in nats (lower is better) and CRPS. Scores are averaged over steps after a 5-step spin-up and over 500 episodes. ± is the SEM: for NBF it is over 3 independently trained models, and for the classical filters it is over episo...
NBF(1024) and NBF(4096) vs. EnKF(100) and PF-Reg(131072), with identical dynamics, observation model, initial belief and evaluation seeds. Appendix Table 12 adds bootstrap PF, PF-OP (locally optimal proposal) and PF-RM (resample-move) with up to 262,144 particles. The best of these at K = 40 reaches RMSE 3.952.
The claim is refuted if, at K = 40, F = 8, σ_obs = 1, a reproduced NBF does not reach a clearly lower RMSE than a localized EnKF(100) under the same settings (for example, NBF RMSE ≥ about 1.4, or within a few SEMs of the EnKF), or if its NLL is not below the EnKF's.
table
Table 1: Lorenz-96 at the held-out F = 8. ms is wall-clock per filter step on one L40S GPU. SEMs are at most 0.2 nats on NLL and 0.03 on RMSE and CRPS.
https://arxiv.org/abs/2510.03614
https://openreview.net/forum?id=D4Tzo5hpy3
true
https://paperswithcode.co/paper/2510.03614
2510.05197
Efficient Prediction of Pass@k Scaling in Large Language Models
[ "Joshua Kazdan", "Colin Sullivan", "Rylan Schaeffer", "Youssef Allouah", "Kyssen Yu", "Noam Levi", "Sanmi Koyejo" ]
poster
main
standard
Repeated sampling raises both what LLMs can do (solving hard math and code problems) and the harm they can cause (jailbreaks succeed eventually). Forecasting pass@k, the chance that at least one of k attempts succeeds, at large k is useful for capability and safety evaluation, but measuring it directly takes at least k...
The proposed estimator models each problem's single-attempt success probability pass_i@1 as drawn from a Beta(α, β) distribution, so that the observed success count s_i out of b_i attempts follows a beta-binomial. α and β are fit by maximum likelihood on the (s_i, b_i) counts (Eq. 15-16), and pass@k is predicted as E_{...
On MATH with Pythia models (160M-12B) and a total budget of 10^4 samples, the Dynamic + Beta-Binomial estimator reaches pass@k prediction MSE of about 2e-3 to 2e-2. Both log-log regression and the discretized-beta estimator stay at about 8e-2 or higher (roughly 0.08-0.3) on all six models, a gap of about 4x to 40x.
Figure 9 (MATH panel), page 23
Mean squared error between predicted and ground-truth pass@k (computed from all 10,000 samples); lower is better; log-scale y-axis. Appendix E describes these MSE-vs-budget plots as 'for fixed k', but the k used in Figure 9 is not stated (Section 5.1 predicts log-spaced k from 100 to 10,000). The shaded bands are not d...
Dynamic sampling + beta-binomial MLE vs. log-log linear regression (uniform sampling, clipped at 1) vs. discretized scaled-beta fit of Schaeffer et al. (uniform sampling), all given the same total sample budget B drawn from the same 10,000-sample pool
At B = 10^4 on MATH/Pythia, the beta-binomial estimator's MSE is not clearly lower (e.g. less than about 3x lower) than the better of the two baselines on most of the six models, or the MSE does not drop steeply with budget as shown.
figure
Figure 9: MSE scaling with increasing budget. As expected, more samples generally leads to a reduction in MSE across all approaches. For some models our approach reaches MSE more than 10x lower than its counterparts.
https://arxiv.org/abs/2510.05197
https://openreview.net/forum?id=kSIarHMFfh
true
https://paperswithcode.co/paper/2510.05197
2510.05416
Correlating Cross-Iteration Noise for DP-SGD using Model Curvature
[ "Xin Gu", "Yingtai Xiao", "Guanlin He", "Jiamu Bai", "Daniel Kifer", "Kiwan Maeng" ]
poster
main
standard
DP-SGD trains models with differential privacy by clipping per-example gradients and adding Gaussian noise, but this costs a lot of accuracy. DP-MF methods such as DP-BandMF instead add noise that is correlated across iterations through a mixing matrix C, so that later noise partly cancels earlier noise at the same pri...
NoiseCurve keeps the DP-BandMF framework unchanged (banded X = C^T C with unit diagonal, the same batch sampling and privacy accounting, and C recovered by Cholesky) and replaces only the objective used to choose X. The new objective is Tr((V^T M V) X^{-1}), where M = Diag(mu_0..mu_{p-1}) holds the eigenvalues of a Hes...
On CIFAR-10 last-layer finetuning of an ImageNet-pretrained ResNet152 (delta=1e-5), NoiseCurve reaches 78.3 ± 0.05% test accuracy at eps=2 and 80.14 ± 0.28% at eps=5, compared with DP-BandMF's 77.33 ± 0.09% and 78.35 ± 0.07% (DP-SGD: 77.14 ± 0.17% and 78.31 ± 0.23%).
Table 1(a), page 7
Test accuracy (%) on CIFAR-10, higher is better; mean ± std over runs (caption says 6 runs, text and Appendix A.3 say 3 seeds per cell)
NoiseCurve vs. DP-BandMF and DP-SGD, same model, data, epochs, batch size and validation-based hyperparameter tuning, at eps = 1, 2, 5
At eps=2 or eps=5, NoiseCurve's mean accuracy is within about one std of DP-BandMF's (e.g. less than ~0.3 points ahead), or DP-BandMF with tuned band size matches or beats it.
table
Table 1. Test mean accuracy and standard deviation (over 6 runs). (a) Last layer finetuning of ResNet152 (convex loss). (b) Full finetuning of a small CNN (nonconvex loss).
https://arxiv.org/abs/2510.05416
https://openreview.net/forum?id=Z96zEg7guN
true
https://paperswithcode.co/paper/2510.05416
2510.05849
ESS-Flow: training-free guidance as Bayesian inference in source space
[ "Adhithyan Kalaivanan", "Zheng Zhao", "Jens Sjölund", "Fredrik Lindsten" ]
poster
main
standard
Training-free guidance steers a pretrained diffusion or flow model toward samples with a target property without retraining it. Most such methods (DPS, D-Flow, PnP-Flow, DAPS) need gradients of the reward or likelihood, and sometimes of the generative map too. In scientific design problems those gradients are often una...
ESS-Flow treats a flow model with a Gaussian source as a deterministic transport map x = T(z), z ~ N(0, I), and samples the target pi(z) proportional to g(T(z)) N(z; 0, I) directly in source space using elliptical slice sampling (ESS). Each MCMC step draws nu ~ N(0, I), proposes z' = z cos(theta) + nu sin(theta) along ...
When guiding FlowMM toward bulk modulus 300 GPa and shear modulus 200 GPa with ALIGNN-predicted properties, ESS-Flow reaches a mean absolute error of 8.99 ± 6.69 GPa and 10.53 ± 9.21 GPa. The best gradient-based baselines reach 39.14 ± 26.47 (DAPS) and 75.48 ± 33.45 (PnP-Flow).
Table 2, page 7
Mean absolute error between the ALIGNN-predicted property of generated materials and the target, in GPa (lower is better). ± is the standard deviation across generated samples (1000 samples, one run), not across seeds.
ESS-Flow vs. D-Flow, PnP-Flow, and DAPS. All use the same FlowMM prior, the same ALIGNN predictor, and the same target and atom count.
With the same FlowMM prior, ALIGNN predictor and settings, ESS-Flow's mean absolute error on bulk or shear modulus is not clearly lower than the best of DAPS or PnP-Flow. For example, the best baseline comes within ~2x of ESS-Flow, or ESS-Flow's bulk-modulus MAE exceeds ~20 GPa.
table
Table 2: Mean and standard deviation of absolute errors between the sample properties and targets, and of energy above hull values.
https://arxiv.org/abs/2510.05849
https://openreview.net/forum?id=qokTHEVYpp
true
https://paperswithcode.co/paper/2510.05849
2510.06388
Truthful Calibration Errors for Multi-Class Prediction
[ "Yuxuan Lu", "Yifan Wu", "Jason Hartline", "Lunjia Hu" ]
poster
main
standard
Binned calibration errors such as the Expected Calibration Error (ECE) are widely used to evaluate and compare probabilistic classifiers, but prior empirical work (Nixon et al. 2019; Minderer et al. 2021) found that model rankings by calibration error can reverse when only the number of bins changes. The paper argues t...
The truthful classwise error LinCE^cw_B averages, over the k classes, a squared binned residual for each one-vs-all coordinate: for class r, bin the scalar reports p_i^(r) with an outcome-independent rule B, then compute (1/n^2) * sum over bins of (sum_{i in bin} (p_i^(r) - 1[y_i = r]))^2. The paper also defines a corr...
On the within-model MobileNetV3-Small-1.0 CIFAR-100 checkpoint pool, the truthful classwise error with 5 quantile bins keeps a Spearman correlation of 0.884 ± 0.007 with classification error, whereas the standard confidence ECE with 5 fixed bins gives -0.277 ± 0.030 and the uncorrected squared confidence error with 5 q...
Table 1 (Appendix F), page 22; illustrated in Figure 3, page 12 and Figure 1, page 3
Spearman rank correlation over temperature-scaled checkpoints (higher = more consistent ranking); ± is 1.96 standard deviations (the paper does not say how the std is estimated); no seed replication
Truthful LinCE^cw (quantile bins) vs. non-truthful ConfECE (fixed bins) and ConfCE (quantile bins), with each error computed at 2000, 20 and 5 bins on the same checkpoints
On a re-run within-model pool, the Spearman correlation between classification error and LinCE^cw_(qua,5) is not clearly positive and not clearly higher than that of ConfECE_(fix,5) (e.g. LinCE^cw below about 0.6, or ConfECE_(fix,5) also above 0.6), or LinCE^cw_(qua,2k) and LinCE^cw_(qua,5) disagree in ranking about as...
table
Spearman rank correlations on the test split for the calibration-error comparisons in our binning-robustness analysis. For each calibration-error family, the table reports the correlation between classification error and each calibration error, as well as the pairwise correlations among calibration errors computed with...
https://arxiv.org/abs/2510.06388
https://openreview.net/forum?id=q98y9pHu2F
true
https://paperswithcode.co/paper/2510.06388
2510.06627
POME: Post Optimization Model Edit via Muon-Style Projection
[ "Yong Liu", "di fu", "Yang Luo", "Zirui Zhu", "Minhao Cheng", "Cho-Jui Hsieh", "Yang You" ]
poster
main
harder
Fine-tuning a pretrained LLM with Adam yields a weight update Delta W = W_ft - W_pre whose singular-value spectrum is dominated by a few directions. Matrix-aware optimizers such as Muon orthogonalize each step's update so that all directions contribute equally, but doing this every step is awkward in sharded (ZeRO/FSDP...
For each selected layer, POME computes the SVD of Delta W = U Sigma V^T, keeps the top-k singular vectors (k = 0.5 * rank(Delta W) by default), sets all retained singular values to one, and rescales: Delta W_hat = alpha * U_k V_k^T, with alpha = beta * ||Delta W|| / ||U_k V_k^T|| (Eq. 12) and beta chosen on a small hel...
Applying POME (up_proj layers, k = 0.5 * rank) to the public MetaMath-Mistral-7B checkpoint raises GSM8K accuracy from 77.9% to 79.5% (+1.6) and MATH accuracy from 28.1% to 28.5% (+0.4), with no extra data or training.
Table 3, page 7
Test accuracy (%) on GSM8K and MATH, higher is better; single evaluation, no error bars or seeds reported
MetaMath-Mistral-7B as released vs. the same checkpoint after the POME edit
With POME applied as described (up_proj, k = 0.5 * rank, beta tuned on held-out or training data, not the test set), the edited model does not improve GSM8K accuracy over the unedited checkpoint evaluated with the same prompt and decoding, or the gain is within the variation obtained across reasonable beta values / eva...
table
Table 3: Effect of POME on the publicly available MetaMath-Mistral-7B model, demonstrating generalization to externally trained checkpoints.
https://arxiv.org/abs/2510.06627
https://openreview.net/forum?id=zA8hNLdmm6
true
https://paperswithcode.co/paper/2510.06627
2510.08141
SCOPE-RL: Stable and Quantitative Control of Policy Entropy in RL Post-Training
[ "Chen Wang", "Zhaochun Li", "Bai Jionghao", "Hexuan Deng", "Guanting Dong", "Ge Lan", "Yue Wang" ]
poster
main
harder
GRPO is a common RL algorithm for post-training reasoning LLMs with verifiable rewards. During training its policy entropy tends to fall steadily (entropy collapse), so sampled outputs become homogeneous and exploration stops early. The usual fixes, entropy bonuses and clip-higher variants such as DAPO, can raise entro...
SCOPE-RL adds an auxiliary policy-gradient term to the GRPO objective. At each update it samples extra rollouts at temperature T = clip(1 + H0 - H(pi_old), 0.8, 1.2), where H(pi_old) is the mean token entropy of the previous update and H0 = 0.5 is the target. Only correct (reward = 1) auxiliary trajectories are kept, w...
On Llama-3.1-8B-Instruct trained on Math12K with matched rollout budgets (3 seeds), SCOPE-RL beats GRPO, DAPO and KL-Cov by more than the seed std on AIME24 (11.25 ± 1.00 vs. best baseline KL-Cov 8.58 ± 0.79, GRPO 7.74 ± 0.34) and on Minerva (29.17 ± 0.56 vs. best baseline GRPO 25.73 ± 1.33).
Table 6 (Appendix A.1), page 14
Pass@1 accuracy (%), higher is better; mean +/- std over 3 training seeds
SCOPE-RL vs. GRPO, DAPO, KL-Cov (CISPO failed to train) on Llama-3.1-8B-Instruct, same data, same number of updates and same total rollout count
With 3 seeds under matched rollout budgets, SCOPE-RL's mean Pass@1 on AIME24 or on Minerva does not exceed the best of GRPO, DAPO and KL-Cov by more than the larger of the two seed stds.
table
Additional results on Llama-3.1-8B-Instruct over three independent random seeds. All methods use identical rollout budgets. Results are reported as mean ± standard deviation.
https://arxiv.org/abs/2510.08141
https://openreview.net/forum?id=Vt62uaRwMd
true
https://paperswithcode.co/paper/2510.08141
2510.08799
SkipSR: Faster Super-Resolution with Token Skipping
[ "Rohan Choudhury", "Shanchuan Lin", "Jianyi Wang", "Hao Chen", "Qi Zhao", "Feng Cheng", "Lu Jiang", "Kris Kitani", "László Jeni" ]
poster
main
harder
Diffusion-based video super-resolution (SR) is the slow, expensive final stage of cascaded video generation and of video restoration, and its cost grows steeply with resolution because diffusion transformers use self-attention over all patches. Existing speed-ups reduce the number of diffusion steps or sparsify attenti...
The paper splits a high-resolution video I (T x H x W x 3) into non-overlapping 4 x 16 x 16 x 3 patches and calls a patch skippable if MSE(P, U(D(P))) <= tau, where D is 4x spatial area downsampling, U is bilinear upsampling and tau = 0.0002 (Eq. 1). To check that skipping does not degrade quality in the latent-diffusi...
With the oracle mask (tau = 0.0002, 4x downsampling), 44.8% of patches are skippable on VBench 720p videos and 31.2% on VideoLQ 720p, and swapping them for bilinear-upsampled latents still gives PSNR 42.24 / 46.61 and LPIPS 0.0400 / 0.0239 against the original, with an estimated diffusion speed-up of 1.8x / 1.5x on See...
Table 1, page 4
Skippable % of 4x16x16 patches; PSNR (higher better), SSIM (higher better), LPIPS (lower better) of the VAE-decoded swapped video vs. the original high-resolution video; speed-up of the SeedVR2 diffusion transformer from dropping skippable tokens. Point estimates only; no error bars or seeds reported.
Original high-resolution video vs. the same video with oracle-skippable latent patches replaced by latents of its 4x down-then-up-sampled version; dense SeedVR2 vs. SeedVR2 with skippable tokens removed (speed only).
On the same datasets at 720p, the skippable fraction under Eq. 1 with tau = 0.0002 is far lower (e.g. under 20% on VBench or AIGC-30), or the swapped reconstruction falls clearly below the reported quality (e.g. PSNR under 40 dB or LPIPS above 0.05 on VBench/VideoLQ), or removing the skippable tokens from SeedVR2-3B yi...
table
Table 1: Oracle Mask Analysis. Using the oracle mask, we measure the reconstruction error of upsampling and swapping simple patches, as well as the resulting expected speedup. We spatially downsample by 4x in all cases.
https://arxiv.org/abs/2510.08799
https://openreview.net/forum?id=fVcbQE6MZo
true
https://paperswithcode.co/paper/2510.08799
2510.12266
HiLoRA: Adaptive Hierarchical LoRA Routing for Training-Free Domain Generalization
[ "Ziyi Han", "Huanyu Wang", "Zeyu Zhang", "Xiangxiang Dai", "Xutong Liu", "John C. S. Lui" ]
poster
main
harder
Community hubs host thousands of task-specific LoRA adapters, which suggests serving new inputs by reusing existing adapters instead of training new ones. In practice inputs come without task labels, may belong to tasks with no matching adapter, and activating a fixed number of whole adapters either brings in interferi...
HiLoRA treats each rank of a LoRA (a row of the down-projection A paired with a column of the up-projection B) as a rank-one component (ROC). At the sequence level, each LoRA is represented by a Gaussian fitted to instructor-base embeddings of m = 20 examples from its training task; the input's length-normalised log-li...
On the ten-task NLI within-cluster setting with LLaMA2-7B (five seen, five unseen tasks), HiLoRA reaches 63.41% average accuracy, versus 56.99% for the best non-HiLoRA baseline (Retriever) and 41.61% for Merged, close to the 65.13% of the oracle task-specific LoRA.
Table 1, page 7
Accuracy (%) per task, higher is better, averaged over 10 NLI tasks; single run, no error bars reported
HiLoRA vs. Retriever, LEGO, Arrow, Phatgoose, Ensemble, Merged and the HiLoRA-GS / HiLoRA-ROC ablations; oracle per-task LoRA as upper reference
With the same LLaMA2-7B LoRA pool and seen/unseen split, HiLoRA's 10-task average accuracy is not at least about 3 points above Retriever (and the other external baselines), or the gap falls within the spread across several random seeds of HiLoRA's multinomial ROC allocation.
table
Table 1: Performance on the NLI cluster using LLaMA2-7B and FLAN-T5-large. Tasks with a white background are set as seen tasks, while those with a gray background are set as unseen tasks. For each task, the best accuracy among all methods is in bold, and the second best is underlined.
https://arxiv.org/abs/2510.12266
https://openreview.net/forum?id=ZbObuTCYWv
true
https://paperswithcode.co/paper/2510.12266
2510.12793
ViCO: A Training Strategy towards Semantic Aware Dynamic High-Resolution
[ "Long Cui", "Weiyun Wang", "Jie Shao", "Zichen Wen", "Gen Luo", "Zhang", "Linfeng Zhang", "Wenhai Wang" ]
poster
main
harder
Multimodal LLMs such as InternVL3.5 use dynamic high-resolution tiling: an image is split into up to 12 patches plus a thumbnail, each encoded as 256 visual tokens, so a single image can cost over 3,000 tokens and visual tokens dominate inference cost for documents, multi-image inputs and video. Existing token-reductio...
ViCO adds a second MLP connector with 16x downsampling (64 tokens per patch) beside the standard 4x connector (256 tokens per patch). In Consistency Training, a policy model sees images in which a random fraction (uniform in [0,1]) of patches use the 64-token connector, and is trained to minimize the KL divergence betw...
On InternVL3.5-8B, ViCO (trained router, 55.0% of patches compressed on average) retains 99.6% of the uncompressed model's average score across 8 benchmarks, versus 95.9% for FastV and 91.2% for SparseVLM at comparable compression; the gap is largest on InfoVQA (78.6 vs 71.6 vs 55.2) and DocVQA (90.8 vs 87.5 vs 75.9).
Table 3, page 7
Benchmark accuracy/score (higher is better) and average relative to Vanilla InternVL3.5-8B (=100%); single runs, no error bars reported.
ViCO (InternVL3.5-8B with consistency training + patch-level router) vs. FastV and SparseVLM applied to vanilla InternVL3.5-8B at comparable average compression; Vanilla uncompressed model as the 100% reference.
With the released ViCO-8B (InternVL3.5-8B-Flash) checkpoint and FastV run on vanilla InternVL3.5-8B at a matched fraction of removed visual tokens, ViCO's InfoVQA/DocVQA scores are not clearly above FastV's (e.g., InfoVQA gap below ~2 points), or ViCO's average relative score falls below FastV's.
table
Table 3. Ablation and comparative study of ViCO across general and strongly OCR-dependent benchmarks. Experiments are conducted on InternVL3.5-8B. For DocVQA and InfoVQA, the validation sets are used for performance evaluation.
https://arxiv.org/abs/2510.12793
https://openreview.net/forum?id=g3Qk3mOpuu
true
https://paperswithcode.co/paper/2510.12793
2510.13397
Assessing the robustness of heterogeneous treatment effects in survival analysis under informative censoring
[ "Yuxin Wang", "Dennis Frauen", "Jonas Schweisthal", "Maresa Schröder", "Stefan Feuerriegel" ]
poster
main
standard
Clinical studies often lose patients to dropout, and when dropout depends on survival time (informative censoring), standard estimators of the conditional average treatment effect (CATE) on survival time, which assume censoring is independent of survival, are biased and the CATE is not point-identified. The paper inste...
For each treatment a, the conditional mean survival time is bounded below by mu-(x,a) = E[T~ | X=x, A=a] (the observed time min(T,C)) and above by mu+(x,a) = nu(0,x,a)[1 - xi(x,a)] + nu(1,x,a) xi(x,a) + gamma(x,a) xi(x,a), where nu(delta,x,a) = E[T~ | Delta=delta, X=x, A=a], xi(x,a) = P(censored | x,a), and gamma is a ...
With domain-knowledge bounds (Case 1) on synthetic informatively-censored data, SurvB-learner has lower bound-RMSE than the plug-in learner in all 9 scenarios, by margins several times the std over 5 runs, e.g. exponential xi=0.2: 2.541 ± 0.138 vs. 3.244 ± 0.152; sin xi=0.2: 0.799 ± 0.020 vs. 1.400 ± 0.067; logistic-si...
Table 1, page 9
RMSE of estimated CATE/CAPO bounds (upper and lower) vs. oracle bounds, lower is better; ± is std over 5 random runs
SurvB-learner (doubly robust two-stage meta-learner) vs. plug-in learner, both using default random forests for nuisance estimation, Case 1 domain-knowledge bounds
In the Case 1 domain-knowledge setting, SurvB-learner's mean RMSE is not lower than the plug-in learner's by more than one std over 5 seeds in a majority of the 9 (function, censoring strength) scenarios.
table
Table 1: Results for experiments with synthetic data. The experiments serve two purposes: (i) to show that our SurvB-learner obtains values close to the oracle bounds, and (ii) to demonstrate that the plug-in learner is not robust and therefore inferior. Experimental details are in Appendix H. We report the mean ± stan...
https://arxiv.org/abs/2510.13397
https://openreview.net/forum?id=pYwXc4sHCJ
true
https://paperswithcode.co/paper/2510.13397
2510.13669
CanvasMAR: Improving Masked Autoregressive Video Prediction With Canvas
[ "Zian Li", "Muhan Zhang" ]
poster
main
harder
Masked autoregressive (MAR) models generate an image as continuous tokens, a few at a time in random order, with a small diffusion head per token. Applied to video prediction frame by frame, each frame starts from a fully masked grid. With only a few spatial sampling steps the early token sets have no global structure ...
CanvasMAR factorises generation into temporal and spatial autoregression. A Temporal ViT (causal across frames, bidirectional within a frame) encodes past latent frames into a temporal embedding. A Canvas ViT takes this embedding and the most recent frame and, in one deterministic forward pass, predicts a 'canvas': a b...
On BAIR video prediction without CFG, adding the canvas to an otherwise identical video MAR lowers debiased FVD at every step count from 1 to 8. At 4 autoregressive steps per frame (the default), FVD drops from about 50 without the canvas to about 32 with the canvas, and at 8 steps from about 35 to about 30.5.
Figure 3(a), page 9
Debiased FVD on BAIR (lower is better), K = 20 generated clips per test video, 256 test videos. No error bars, seeds or confidence intervals are reported. Values are read off the plot and are approximate.
CanvasMAR (with canvas, with or without motion-aware sampling) vs. the same architecture trained from scratch without the canvas component, both without classifier-free guidance, across 1-8 spatial AR steps per frame
A matched re-implementation in which the no-canvas model reaches FVD within a few points of the canvas model at 2-4 AR steps on BAIR (e.g. no-canvas FVD below about 40 at 4 steps when the canvas model is about 32), or in which the gap shrinks to within seed-to-seed variation.
figure
Fig. 3: Component-level analysis. In the first two figures, classifier-free guidance is not used, and MAS represents the motion-aware sampling order. (a) Effectiveness of canvas and motion-aware sampling on BAIR. (b) Effectiveness of canvas and motion-aware sampling on UCF-101. (c) Effectiveness of compositional classi...
https://arxiv.org/abs/2510.13669
https://openreview.net/forum?id=znXlOaeZCI
true
https://paperswithcode.co/paper/2510.13669
2510.13879
Catch Your Breath: Adaptive Computation for Self-Paced Sequence Production
[ "Alexandre Galashov", "Matt Jones", "Nan Rosemary Ke", "Yuan Cao", "Vaishnavh Nagarajan", "Michael Mozer" ]
poster
main
harder
One way to give a transformer more computation per token without making it deeper is to insert <pause> tokens into the input stream, so each real token gets extra parallel forward steps before the next prediction. The standard recipe (Think Before You Speak, TBYS; Goyal et al. 2024) trains with ordinary cross-entropy r...
Catch Your Breath (CYB) inserts M-1 pause tokens after every real token (all pauses get the RoPE position of the preceding real token and distinct identities <pause1>, <pause2>, ...). At each step i the model outputs a <don't know> probability d_i (a repurposed unused vocabulary token, renormalised out of the next-toke...
Fine-tuning Gemma3-4B on C4 with 3 pause tokens after every real token, the CYB loss reaches C4 eval perplexity 10.131 vs. 10.359 for TBYS cross-entropy under identical pauses, data and compute (3-seed values 10.131/10.134/10.129 vs. 10.359/10.360/10.358); CYB with 1 pause (10.351) also matches TBYS with 3 pauses.
Table F.2 (Appendix F.1), page 22; seed replications in Section 4 text, page 6; same comparison shown in Figure 3 (right)
C4 validation-set perplexity (lower is better). The table reports single values; the text reports three replications (different data order) for baseline, CYB-3-pause and TBYS-3-pause only, with spread ~0.005. No error bars for 1- and 2-pause variants.
CYB vs. TBYS at 1, 2 and 3 pauses per token, matched in pause insertion, position encoding, data and compute; plus no-pause baselines (data-matched and 4x-sequence compute-matched)
With matched fine-tuning (same model, data, pauses and budget), CYB with 3 pauses does not achieve lower C4 eval perplexity than TBYS with 3 pauses by clearly more than the seed-to-seed spread (e.g., the gap is below ~1% relative or reverses).
table
Table F.2: Results for fine-tuned (on C4) Gemma3-4B. Perplexity on eval set of C4. For relative improvement, we use the formula (5). In bold we highlight the best result – the lowest perplexity and the highest relative improvement.
https://arxiv.org/abs/2510.13879
https://openreview.net/forum?id=RfZGk8kzTr
true
https://paperswithcode.co/paper/2510.13879
2510.16014
STAR: Boosting Time Series Foundation Models for Anomaly Detection Through State-Aware Adapter
[ "Hanyin Cheng", "Ruitong Zhang", "Yuning Lu", "Yang Shu", "Peng Chen", "Yuan Jun", "Meng Wang", "Bin Yang", "Chenjuan Guo" ]
poster
main
harder
Time series foundation models (TSFMs) are increasingly used for multivariate time series anomaly detection. Industrial data often mixes numerical sensor channels (flow, speed) with discrete state variables (valve open/closed, machine position, day of week) that act as conditions on how the numerical channels should beh...
STAR is an adapter trained during fine-tuning while the TSFM backbone is frozen; only the numerical variables pass through the backbone. A State Extractor embeds each state variable from sinusoidal encodings of its variable index and current state value, routed (soft top-K) into a small learnable State Memory of N vect...
On the Genesis dataset, adding STAR to a frozen TSFM gives higher VUS-ROC than the stronger of LoRA and standard fine-tuning of the same backbone for all four backbones: DADA 0.911 vs 0.832 (standard; LoRA 0.818), UniTS 0.850 vs 0.777 (LoRA), Moment 0.950 vs 0.908 (LoRA), Timer 0.944 vs 0.887 (LoRA).
Table 1, page 8
VUS-ROC (V-R), higher is better; AUC-ROC and VUS-PR also reported. Single numbers per cell; no seeds, standard deviations or confidence intervals are reported.
Backbone + STAR vs. the stronger of Backbone + LoRA and standard fine-tuning (LoRA for UniTS, Moment and Timer; standard fine-tuning for DADA) for DADA, UniTS, Moment and Timer, each fine-tuned on 10% of the Genesis data
Re-running the three fine-tuning regimes on Genesis, STAR's V-R fails to exceed the better of LoRA and standard fine-tuning for at least two of the four backbones, or the average margin over that baseline falls below ~0.02 or within the seed-to-seed spread of the reproduction.
table
Table 1: Results of adapters for different TFSMs. The better results are highlighted in bold.
https://arxiv.org/abs/2510.16014
https://openreview.net/forum?id=KCWC9dFVBr
true
https://paperswithcode.co/paper/2510.16014
2510.16157
Zeroth-Order Sharpness-Aware Learning with Exponential Tilting
[ "Xuchen Gong", "Tian Li" ]
poster
main
harder
Zeroth-order (gradient-free) optimizers such as MeZO fine-tune language models using only loss evaluations at randomly perturbed parameters, so they need about as much memory as inference. The standard two-point estimator implicitly minimizes the average loss in a neighborhood of the parameters, which acts as a weak sh...
ZEST minimizes the tilted SAM objective F_t(x) = (1/t) log E_eps[exp(t f(x+eps))], which interpolates between the average loss (t -> 0, i.e. MeZO) and the max loss (t -> infinity, i.e. SAM). Per step it samples k random Gaussian directions v_i (regenerated from seeds rather than stored), evaluates the minibatch loss at...
When RoBERTa-base is fine-tuned on 512 examples per class with 30% of labels flipped, ZEST_N beats MeZO in test accuracy by 5.9 points on QQP (68.3 vs. 62.4), 5.7 on SNLI (64.9 vs. 59.2) and 3.1 on MNLI (63.4 vs. 60.3), with identical zeroth-order budget and memory.
Table 3, page 9
Test accuracy (%), higher is better; single number per cell, no error bars or seed count reported
ZEST_N (tilted zeroth-order estimator, t tuned in {1,5,20}) vs. MeZO (vanilla two-point zeroth-order estimator, equivalent to t = 0) on RoBERTa-base with 30% noisy labels; first-order SGD/ESAM/SAM/TSAM shown for reference
Over several seeds with the same tuning grids, ZEST_N's mean test accuracy on noisy QQP, SNLI and MNLI does not beat MeZO's by clearly more than the seed-to-seed spread (e.g. the gap falls below ~1 point or flips sign on at least two of the three tasks).
table
Table 3: Experiments on RoBERTa-Base (512 training examples per class with 30% noisy labels). The objectives of each method are in Table 1.
https://arxiv.org/abs/2510.16157
https://openreview.net/forum?id=8LXSBQlinu
true
https://paperswithcode.co/paper/2510.16157
2510.16937
Prediction-Augmented Trees for Reliable Statistical Inference
[ "Vikram Kher", "Argyris Oikonomou", "Manolis Zampetakis" ]
poster
main
standard
Prediction-powered inference (PPI) and its tuned variant PPI++ build confidence intervals for a quantity such as a population mean from a small set of n labeled samples, a large set of N unlabeled samples, and a black-box ML predictor f. They add the mean prediction on the unlabeled data to a single global estimate of ...
PART (Prediction-Augmented Residual Tree) builds a CART-style binary tree over the feature space. Candidate split thresholds are midpoints between consecutive empirical quantiles (levels 1/n, ..., (n-1)/n) of each feature in the unlabeled data. Each split greedily minimizes the Variance of Mixture of Splits criterion V...
When estimating mean Vinho Verde wine quality with random-forest predictions, depth-2 PART gives narrower confidence intervals than PPI++ at every labeled size n from 300 to 600: about 0.128 vs 0.150 at n=300 and 0.093 vs 0.107 at n=600 (roughly 10-15% narrower). Both methods' coverage stays at or above the 0.90 target...
Figure 4, page 17
Average confidence-interval width over 100 random labeled/unlabeled splits (lower is better). Error bars are one standard deviation of the width across the 100 trials. Empirical coverage is also reported, against a nominal 0.90 target. Values are read off the plot.
PART (max depth 2) vs. PPI++ (power-tuned PPI) on identical splits, predictions and confidence level
Over 100 random splits, PART's average CI width at some n in 300-600 is not clearly below PPI++'s (for example, the gap is within one std of the width). Also refuted if PART's empirical coverage falls clearly below the 0.90 target, for example below about 0.85.
figure
Figure 4: Estimating the mean quality of Portugese Vinho Verde wine [20] (see Section 5 for testing methodology).
https://arxiv.org/abs/2510.16937
https://openreview.net/forum?id=fLL6UFq9R4
true
https://paperswithcode.co/paper/2510.16937
2510.17385
Strengthening LLMs for Tabular Prediction with Structural Priors
[ "Pengxiang Cai", "Zihao Gao", "Wanchen Lian", "Guocong Li", "Jintai Chen" ]
poster
main
harder
Tabular prediction is dominated by gradient-boosted trees and specialised models such as TabPFN, while LLMs, despite cross-task transfer and readable reasoning, remain weak on tables. RL post-training with GRPO has improved LLM reasoning in maths, but on tabular prediction the outcome reward is sparse (a base model oft...
Each table row is serialised as 'The [feature] is [value].' sentences plus a task question. PRPO samples m label-preserving column permutations of a row, generates G rollouts per permutation, and gives each rollout a rule-based reward (classification: 1.0 correct, 0.1 wrong but well-formatted, 0 otherwise; regression: ...
Under a matched budget of 20 rollouts per row, full PRPO post-training of Qwen3-8B-Base reaches about 0.843 mean classification accuracy at step 700, versus about 0.745 for GRPO with 20 rollouts (A1), 0.739 for standard GRPO (A0) and 0.765 for GRPO with random column order (A2, a stated gap of +0.078); on regression PR...
Figure 4, page 9 (exact gaps stated in Section 3.3, page 8)
Mean test accuracy over classification datasets (higher is better) and mean NMAE over regression datasets (lower is better) against training step; single run, no error bars or seeds reported; values read off the plot are approximate except the gaps stated in the text
Full PRPO (A5, m=4, G=5) vs. standard GRPO (A0, G=5), GRPO with more rollouts (A1, G=20), GRPO with random column-order training (A2, G=20), intra-only (A3) and inter-only (A4) permutation advantages, all at 20 rollouts per original sample
Re-running the compute-matched comparison on the same datasets, full PRPO's final mean classification accuracy is less than about 0.03 above GRPO with 20 rollouts (A1) or random column-order GRPO (A2), or the gap is within the spread across seeds; or PRPO's regression NMAE is not lower than the GRPO variants.
figure
Figure 4: Attribution ablation on classification and regression datasets. A0 is standard GRPO; A1–A5 isolate rollout count, random column order, intra-only, inter-only, and full PRPO under matched rollout budgets.
https://arxiv.org/abs/2510.17385
https://openreview.net/forum?id=pTunYUdPGz
true
https://paperswithcode.co/paper/2510.17385
2510.18239
LIME: Link-based User-item Interaction Modeling with Decoupled XOR Attention for Efficient Test Time Scaling
[ "Yunjiang Jiang", "Ayush Agarwal", "Yang Liu", "Yihan Wu", "Haoran Liu", "Bi Xue" ]
poster
main
harder
Ranking models for recommendation trade accuracy against serving cost. Two-tower models are cheap because the user and item representations are computed independently, but they interact only through a final dot product. Target-attention transformers such as DIN or HSTU let each candidate attend over the user's interact...
LIME introduces ℓ learned global 'link embeddings' L. On the user side, L is contextualized with user features (MLP) and then personalized by attending over the user history E, producing L^P. In LIME-XOR this user module is a 3-layer HSTU-style block with an 'XOR' mask: history tokens attend only to link tokens and lin...
On Taobao-Ad with five seeds, LIME-XOR (32 links) reaches AUC 0.646799 ± 0.000239, above the efficient baselines TTSN (0.645368 ± 0.000216) and VISTA with 32 seed embeddings (0.646075 ± 0.000224), and has the lowest log loss of all five models (0.192545 ± 0.000111).
Table 1, page 8
AUC (higher is better), also gAUC and log loss (lower is better); mean ± standard deviation over 5 seeds (VISTA label says 32 seeds, which refers to its 32 seed embeddings)
LIME-XOR (32 links) vs. TTSN (sum-pooling two-tower) and VISTA (authors' implementation, 32 seed embeddings), with DIN and HSTU as more expensive target-attention references, all on the same Taobao-Ad split and training protocol
Over 5 seeds on Taobao-Ad (32 links, matched protocol), LIME-XOR's mean AUC does not exceed both TTSN's and VISTA's by more than one seed std. (The log-loss lead over VISTA, DIN and HSTU is smaller than one reported std, so log loss alone should not be used to confirm or refute the claim.)
table
Table 1: Five-seed Taobao-Ad results (mean ± standard deviation). Lower log loss is better.
https://arxiv.org/abs/2510.18239
https://openreview.net/forum?id=Lhbpwyn5ox
true
https://paperswithcode.co/paper/2510.18239
2510.19773
Estimating Model-Level Membership Inference Vulnerability Without Reference Models
[ "Euodia Dodd", "Natasa Krco", "Igor Shilov", "Matthew R Wicker", "Yves-Alexandre de Montjoye" ]
poster
main
harder
Membership inference attacks (MIAs) are the standard way to measure how much a trained model leaks about its training data, usually reported as the attack's true positive rate at a very low false positive rate. The strongest attack, LiRA, needs tens to hundreds of reference models trained like the target model, which m...
The target is an image classifier trained on a random 50% of a dataset's training split (members), with the other 50% held out (non-members), following Carlini et al. (2022). Ten architectures (ResNet-20, ResNet-18, WRN28-2, WRN40-4, WRN28-10, MobileNetV2, DenseNet121, VGG11, VGG16, plus ImageNet-pretrained ViT-B-16 fi...
Across 37 image-classifier configurations (10 architectures x 4 datasets), a one-parameter linear fit of reference-free LOSS TNR@FNR=1e-3 predicts online LiRA TPR@FPR=1e-3 (K=64) with RMSE 0.036 (R^2 0.944), better than RMIA with 2 reference models (RMSE 0.046) and the best reference-free baselines LT-IQR AUC and LOSS ...
Table 1, page 8 (scatter in Figure 3, page 8; extended baselines in Table 4, page 23)
R^2, RMSE and MAE of a one-parameter anchored linear fit to LiRA TPR@FPR=1e-3 across configurations; lower RMSE is better. No error bars on these values (the paper reports only bootstrap confidence bands around the fitted line in Figure 3).
LOSS TNR (reference-free) vs. RMIA with 2 reference models, LT-IQR AUC, LOSS AUC, KS distance and train-test accuracy gap, all fit against the same LiRA TPR values
On a reproduced set of image configurations, the anchored linear fit of LOSS TNR to LiRA TPR@FPR=1e-3 has RMSE no lower than that of LOSS AUC (or of RMIA with 2 reference models), or its RMSE is far above 0.036 (e.g. above 0.068).
table
Table 1: Performance of reference-free statistics and RMIA as predictors of LiRA TPR@FPR=10^-3, across the 10 image-classification architectures and 4 datasets of Section 4. Each statistic is mapped to LiRA TPR by a one-parameter least-squares fit anchored at that statistic's no-signal point: the origin for tail statis...
https://arxiv.org/abs/2510.19773
https://openreview.net/forum?id=cEP6vewR7h
true
https://paperswithcode.co/paper/2510.19773
2510.20535
ARC-Encoder: learning compressed text representations for large language models
[ "Hippolyte Pilchen", "Edouard Grave", "Patrick Perez" ]
poster
journal:TMLR
harder
Long contexts from retrieval-augmented generation or chain-of-thought make LLM inference expensive, because prefill cost grows with the number of input tokens. Hard compression such as LLMLingua2 deletes tokens and works with any model, but it only achieves about 2x compression. Soft compression maps text to a few dens...
ARC-Encoder is Llama3.2 3B with its last two layers removed and no causal mask. In the self-attention of its final layer, consecutive queries are averaged in groups of x (the pooling factor, 4 or 8) and attend to the unpooled keys and values, so the encoder outputs n/x vectors for n input tokens. A 2-layer MLP without ...
With a frozen Mistral 7B base decoder and 5-shot evaluation, ARC4-Encoder (4x pooling) averages 46.5 over NQ/TQA/HQA/SQuAD/FLORES/CNN, versus 41.4 for LLMLingua2 (1.9x), 39.5 for PISCO-like at 4x and 38.4 for ICAE-like; the open-book full-text score is 49.2. On SQuAD it scores 71.1 EM vs. 59.2 for the best baseline.
Table 1, page 7
Exact match (NQ, TQA, HQA, SQuAD), BLEU (FLORES), ROUGE-L (CNN), and their unweighted average; higher is better. Table 1 reports single runs (fine-tuning seed fixed to 0) with no error bars. For reference, Tables 5-7 report std over 3 fine-tuning seeds for a closely related ARC8 model: about 0.1-0.4 on the average and ...
ARC4-Encoder^M (Mistral-specific) vs. LLMLingua2, PISCO-like (~32 memory tokens and 4x chunked), ICAE-like and xRAG-like, all with the same frozen Mistral 7B decoder (PISCO-like also LoRA-tunes the decoder); closed-book and open-book as reference points.
A reproduced ARC4-Encoder on Mistral 7B averages within about 1 point of the best re-run compression baseline (LLMLingua2 or PISCO-like 4x) under the same 5-shot protocol, or fails to beat LLMLingua2 on average.
table
Table 1: Main comparison of ARC-Encoder and other models. 'PF' (pooling factor): the token reduction factor (e.g., 4x) for fixed-ratio methods or the number of compressed tokens used, e.g. ~16, when this number is fixed as this yields benchmark-dependent ratios; 'Param.': number of parameters of the encoder; 'Avg. leng...
https://arxiv.org/abs/2510.20535
true
https://paperswithcode.co/paper/2510.20535
2510.23254
Optimal In-context Adaptivity and Distributional Robustness of Transformers
[ "Tianyi Ma", "Tengyao Wang", "Richard J Samworth" ]
poster
main
harder
In-context learning (ICL) theory usually assumes that a Transformer is tested on the same task distribution it was pretrained on. In practice, models are pretrained on a mixture of tasks of different difficulty and tested on a shifted distribution. The paper asks whether a Transformer pretrained on a mixture of nonpara...
Simulation (Section 5, Appendix I): single-index regression tasks with n = 30 in-context examples, ambient dimension d = 5, index dimension p = 1, noise sigma = 0.01 and covariates uniform on the unit ball. The regression link function is a random Besov function with smoothness alpha in {2, 2.5, 3, 4}, generated by a r...
A single Transformer pretrained on a uniform mixture of single-index regression tasks with smoothness alpha in {2, 2.5, 3, 4} reaches test MSE that decreases strictly with alpha, from about 4.5e-3 at alpha = 2 to about 0.3e-3 at alpha = 4 (no shift), with log MSE approximately linear in 2alpha/(2alpha+1). Under the wit...
Figure 4, page 10 (also Figure 2, page 2; more shifts in Figure 5, page 45)
Test-time query MSE (lower is better) over 100,000 random test functions per alpha; error bars are 90% confidence intervals over test functions (single training run, no seeds)
MSE across smoothness levels alpha for the same pretrained model, and shifted vs. unshifted test distributions. No competing estimator is evaluated.
MSE is not monotonically decreasing in alpha (CIs overlap or the order reverses between adjacent alpha levels), or log MSE departs clearly from a linear trend in 2alpha/(2alpha+1), or the shifted MSE is many times larger than the unshifted MSE at some alpha.
figure
Figure 4: MSE and log MSE at test time based on 100,000 random test functions. Error bars represent 90% confidence intervals. (a) MSE against alpha. (b) Log MSE against 2alpha/(2alpha+1).
https://arxiv.org/abs/2510.23254
https://openreview.net/forum?id=5YXJKkV5dy
true
https://paperswithcode.co/paper/2510.23254
2510.25110
DEBATE: A Large-Scale Benchmark for Evaluating Opinion Dynamics in Role-Playing LLM Agents
[ "Yun-Shiuan Chuang", "Ruixuan Tu", "Chengtao Dai", "You Li", "Binwei Yao", "Michael Tessler", "Sijia Yang", "Dhavan Shah", "Robert Hawkins", "Junjie Hu", "Timothy T Rogers" ]
poster
evaluations_datasets
standard
Researchers increasingly simulate how opinions change in groups by having role-playing LLM agents (RPLAs) talk to each other, but such simulations are known to drift toward unnatural consensus, and there has been little real human group data to check them against. DEBATE collects 4-person online deliberations on 107 co...
Each human participant is paired with a 'digital twin' agent whose prompt (memory) holds the participant's demographics, initial 6-point Likert opinion with free-text justification, their first tweet, and the interaction history. In Full Dynamics Simulation (the paper's primary setting), the four agents of a group roll...
On the DEBATE group-generalization test split under Full Dynamics Simulation, zero-shot Llama-3.1-8B-Instruct agent groups over-converge in private opinions relative to the matched human groups: mean within-group private-opinion ΔSD is −0.41 for the agents vs. −0.13 for humans (p ≈ 0.020), and every one of the seven ze...
Figure 4 (left panels), page 8; numbers in Section 5.3 text and Appendix Q (page 28)
Mean over groups of ΔSD = SD(final) − SD(initial) of the 4 members' 6-point private opinions (more negative = more convergence). Error bars are bootstrap standard errors over groups; the p-value is the paper's normal approximation on the aggregate bars. Single simulation run per model, no seed variance reported.
Simulated agent groups (zero-shot Llama-3.1-8B-Instruct, plus the six other zero-shot LLMs) vs. the real human groups they are twins of, on the same 136 test groups and topics
Re-simulating the group-generalization test split with Llama-3.1-8B-Instruct in Full Dynamics Simulation gives a private-opinion mean ΔSD within about one bootstrap SE of the human value (≈ −0.13), or less negative than it.
figure
Figure 4: Post-training convergence summaries and stance-SD trajectories on the group-generalization test split. The left two panels report public and private C^c(m); the right two show the matching stance-SD trajectories. More negative bars indicate stronger convergence. Error bars denote bootstrap standard errors, an...
https://arxiv.org/abs/2510.25110
https://openreview.net/forum?id=qfFstz92T6
true
https://paperswithcode.co/paper/2510.25110
2510.26020
PORTool: Importance-Aware Policy Optimization with Rewarded Tree for Multi-Tool-Integrated Reasoning
[ "Feijie Wu", "Weiwu Zhu", "Yuxiang Zhang", "Soumya Chatterjee", "Jiarong Zhu", "Fan Mo", "Rong Luo", "Jing Gao" ]
poster
main
harder
LLM tool-use agents trained with reinforcement learning from outcome-only rewards face a credit-assignment problem: a single reward for the whole trajectory says nothing about which intermediate tool calls caused success or failure. GRPO-style methods broadcast the same advantage to every step, which can reinforce bad ...
PORTool samples the n = 8 rollouts per query as a bounded-branching tree in which trajectories share prefixes and then diverge at selected tool-call steps. A GPT-4o judge labels each finished trajectory true / false / unable_to_answer (+1 / -1 / 0). Each step gets an importance score R(s) = G over descendant trajectori...
On the 535-query held-out set, PORTool reaches 51.98 ± 1.09% final-answer accuracy with Qwen-2.5-7B-Instruct versus 48.23 ± 1.06% for the best baseline (AgentFlow), and 46.60 ± 1.22% with Qwen-3-1.7B versus 42.76 ± 1.78% for the best baseline (GRPO with format reward), while also using the fewest tool-call steps (3.07 ...
Table 1, page 8
Final-answer accuracy (%), higher is better, judged by GPT-4o (5-vote majority) plus human adjudication; ± is described as an uncertainty estimate from judge variance (Appendix C.3), not standard deviation over training seeds. Reported numbers are the average of the best three checkpoints during training (Appendix C.6)...
PORTool vs. GRPO, GRPO_fm, DAPO, ARPO, ARPO_fm, AgentFlow, SimpleTIR and ToRL, all RL-trained from the same SFT warm start on the same data and tool environment, for two backbones
Training PORTool and the strongest baselines (AgentFlow, ARPO, GRPO_fm) under matched settings, PORTool's accuracy is within about 1-2 points of the best baseline for either backbone, or the gap disappears across training seeds, or PORTool does not use fewer tool-call steps.
table
Table 1 Performance comparisons among different RL training methods on the evaluation dataset
https://arxiv.org/abs/2510.26020
https://openreview.net/forum?id=54keqZlySs
true
https://paperswithcode.co/paper/2510.26020
2510.26401
Outlier-Robust Multi-Output Gaussian Processes
[ "Joshua Rooijakkers", "Leiv Rønneberg", "Francois-Xavier Briol", "Jeremias Knoblauch", "Matias Altamirano" ]
poster
main
standard
Multi-output Gaussian processes (MOGPs) model several correlated response variables jointly and have a closed-form posterior when the noise is Gaussian. That assumption makes them fragile: a single outlier in one output distorts predictions for that output and, through the cross-output correlation, for the other output...
R-MOGP replaces the likelihood with a generalised-Bayes posterior built on a weighted Fisher divergence, extending robust conjugate GPs (RCGPs) to multiple outputs. Each observation y_{i,t} gets an inverse-multiquadric weight w_t = beta_t (1 + ((y_t - gamma_t)/c_t)^2)^(-1/2), where the centre gamma_t is the conditional...
On UCI Energy Efficiency with 10% of heating-load observations contaminated, R-MOGP reaches test RMSE 0.17 ± 0.02 (uniform outliers) and 0.16 ± 0.02 (asymmetric outliers) versus 2.27 ± 0.29 and 2.18 ± 0.18 for a standard MOGP with the same kernel, while matching the MOGP without outliers (0.12 ± 0.01 for both).
Table 2, page 9
Test RMSE (lower is better) and NLPD (lower is better) on standardised outputs; ± is the standard deviation over 10 random train/test splits
R-MOGP (IMQ weights, w-LOO-CV) vs. standard MOGP (Gaussian likelihood, LOO-CV), same ICM kernel and data splits; t-MOGP and L-MOGP (variational GPflow) also reported
Under uniform or asymmetric 10% outliers, R-MOGP's RMSE is not clearly below the MOGP's (e.g. not at least 2x lower, or within a few std of each other), or R-MOGP's RMSE in the no-outlier setting is clearly worse than the MOGP's (outside ~1 std of 0.12).
table
Table 2: Average and standard deviation of RMSE and NLPD on the Energy Efficiency dataset under different outlier scenarios (10 seeds per scenario). Best results are highlighted in bold. Figure 4: Average runtime per function evaluation on the Energy Efficiency dataset across 40 runs.
https://arxiv.org/abs/2510.26401
https://openreview.net/forum?id=4tfLhUSLnF
true
https://paperswithcode.co/paper/2510.26401
2510.27329
Reinforcement Learning for Long-Horizon Unordered Tasks: From Boolean to Coupled Reward Machines
[ "Kristina Levina", "Nikolaos Pappas", "Athanasios Karapantelakis", "Aneta Vulgarakis Feljan", "Jendrik Seipp" ]
poster
main
harder
Reward machines (RMs) are finite automata that expose a task's reward structure to an RL agent, so it can handle non-Markovian goals and learn more efficiently. When a task has N subtasks that may be done in any order (for example, collecting N boxes), a Boolean RM needs one state per subset of completed subtasks, whic...
The paper introduces numeric RMs (unordered subtasks are folded into a counter), agenda RMs (each state is labelled <depth, remaining subtasks, current objective>, so symmetric states merge), and coupled RMs (an agenda state whose objective is a set of subtasks is split into one coupled state per subtask, and the agent...
On tabular Delivery with 8 unordered boxes, QCoRM reaches the optimal average reward per step within about 100k environment steps (median of 10 seeds). The strongest baseline, CRM with agenda RMs (T-CRM), is still well below that level after 1M steps (roughly 75% of QCoRM's plateau, read off the plot). Agenda-RM QRM st...
Figure 3b, page 7 (text in Section 5.1, page 6)
Average reward per step during training (higher is better; the y-axis has no numeric ticks). The curve is the median over 10 seeds, and the shaded band is the 25th-75th percentile. No other error statistics are reported.
QCoRM vs. T-QRM, T-CRM, T-HRM and DiRL with the same tabular Q-learning hyperparameters and a 1M-step budget. Boolean-RM variants (B-QRM, B-CRM, B-HRM) could not be run at 8 boxes because they exceed memory.
With 8 boxes, T-CRM (or another baseline) reaches QCoRM's final average reward per step within 1M steps, with overlapping interquartile ranges, or QCoRM does not reach a stable optimal plateau within the first ~250k steps.
figure
Figure 3: Results of QCoRM (ours) and baselines, Q-learning (QRM), QRM with counterfactual reasoning (CRM), hierarchical HRM, and DiRL. Boolean RMs (B-QRM, B-CRM, B-HRM) and our agenda RMs (T-QRM, T-CRM, and T-HRM) were tested for Delivery (a,b), Office (e,f), Water (i,j), and HalfCheetah (m,n). As DiRL does not allow ...
https://arxiv.org/abs/2510.27329
https://openreview.net/forum?id=ovNLRgukle
true
https://paperswithcode.co/paper/2510.27329
2511.06571
Rep2Text: Decoding Full Text from a Single LLM Token Representation
[ "Haiyan Zhao", "Zirui He", "Yiming Tang", "Fan Yang", "Ali Payani", "Dianbo Liu", "Mengnan Du" ]
poster
main
standard
LLM hidden states are often treated as opaque, yet if the input text can be reconstructed from them, intermediate activations leak private input data and also reveal what information a model retains. Prior inversion work mostly targets sentence embeddings (e.g. Vec2Text) or uses the hidden states of all tokens. This pa...
Rep2Text takes the last-token residual-stream vector h from a fixed layer of a frozen target model (here Mistral-7B-v0.1 or Llama-3.1-8B, layer 10 by default) and maps it with a trainable adapter into k soft token embeddings in the input embedding space of a frozen decoding LLM (here Qwen-2.5-14B). The adapter is a two...
Inverting Mistral-7B-v0.1 last-token representations of out-of-distribution clinical summaries, Rep2Text (adapter-only, frozen Qwen-2.5-14B decoder, trained only on Wikipedia) reaches ROUGE-1 0.37, Token F1 0.26 and topic score 0.64, versus 0.14, 0.13 and 0.21 for a Vec2Text hypothesizer trained on the same data; the s...
Table 2, page 8
ROUGE-1, Token F1 (token level), BERTScore, and GPT-4.1-mini topic score (0-1, all higher is better), averaged over the test set. No standard deviations, seeds or confidence intervals are reported (single run).
Rep2Text vs. Vec2Text Base (T5-base hypothesizer) and Vec2Text + 50-step corrector, all inverting the same last-token representations and trained on the same Wikipedia data, evaluated on OOD clinical summaries (and on in-distribution Wikipedia for reference).
On the OOD clinical summaries, a Vec2Text hypothesizer trained on the same Wikipedia last-token representations reaches ROUGE-1 or Token F1 close to Rep2Text's (e.g. a gap under about 0.05 ROUGE-1 instead of about 0.23), or Rep2Text's clinical ROUGE-1 falls to the Vec2Text level of about 0.14.
table
Table 2: Inversion comparison between Vec2Text and our method with input sequences of no more than 32 tokens. (* denotes Vec2Text; R1/R2/RL = ROUGE, BS = BERTScore, SS/ES/TS = structure/entity/topic scores from GPT-4.1-mini.)
https://arxiv.org/abs/2511.06571
https://openreview.net/forum?id=OET7WYchkH
true
https://paperswithcode.co/paper/2511.06571
2511.08579
Training Language Models to Explain Their Own Computations
[ "Belinda Z Li", "Zifan Carl Guo", "Vincent Huang", "Jacob Steinhardt", "Jacob Andreas" ]
poster
main
standard
When language models are asked to explain their decisions, the explanations often sound plausible but do not reflect the computation that actually produced the output. For example, models use a hint injected into a multiple-choice question without saying so. This paper asks whether a model can be fine-tuned to describe...
Input ablation task (Section 2.4, 5.2; Appendix G.3, H.3): MMLU multiple-choice questions c are given to the target model (Qwen3-8B, used with its chat template) with an injected hint x̃ = 'Hint: The answer is B' (the letter is chosen at random among the four options). The ground-truth explanation is obtained by also r...
On the MMLU hint-ablation task with Qwen3-8B as the target, a Qwen3-8B explainer fine-tuned on Qwen3-8B's own ablation outcomes reaches 83.4 ± 1.0 Exact Match (87.0 Has-Changed F1, 90.6 Content Match), compared with 58.1 ± 1.3 Exact Match (70.5 F1, 71.6 Content Match) for Llama-3.1-8B fine-tuned on the same data.
Table 2, page 7 (input ablation columns); repeated in Table 6, page 20
Exact Match accuracy, Has-Changed macro-F1 and Content Match accuracy (%), higher is better; ± is the standard error reported by the paper ('mean ± standard error'; it does not say over what, presumably test examples, and reports no seed variance); the paper marks entries not significantly different from the best by a ...
Qwen3-8B explaining itself vs. Llama-3.1-8B explaining Qwen3-8B, both fine-tuned on identical training data (untrained prompted Qwen3-8B as a reference floor)
Fine-tuning both explainers on the same Qwen3-8B hint-ablation data, the Qwen3-8B explainer's Exact Match is not clearly higher than Llama-3.1-8B's (e.g. the gap is under ~10 points or is within a few standard errors).
table
Table 2. A target model's intervention outcomes are best predicted by itself, shown through activation patching and input ablation. We train Qwen3-8B to verbalize its own intervention outcomes, and compare against training a different model (Llama-3.1-8B), and also against an untrained version of Qwen3-8B. Scores (mean...
https://arxiv.org/abs/2511.08579
https://openreview.net/forum?id=P0tEbOYZ6N
true
https://paperswithcode.co/paper/2511.08579
2511.09465
Branching Flows: Discrete, Continuous, and Manifold Flow Matching with Splits and Deletions
[ "Lukas Billera", "Hedwig Nora Nordlinder", "Jack C Ryder", "Anton Oresten", "Aron Stålmarck", "Theodor M Björk", "Ben Murrell" ]
poster
main
harder
Diffusion and flow matching models generate a state with a fixed number of elements, so they need the sequence length, the atom count, or the number of residues to be fixed in advance. That is awkward whenever the length is genuinely unknown, for example when designing the complementarity-determining region of an antib...
Branching Flows is formulated in Generator Matching. A latent Z = (X1+ø, X0, T, A) couples an initial sample x0 to a data sample x1: the data sequence is first augmented with 'to-be-deleted' states, then a forest of labelled binary plane trees T is sampled whose roots are the elements of x0 and whose leaves are the ele...
On unconditional antibody heavy-chain generation with architecture and training matched, Branching Flows matches the data distribution better than Edit Flows on diversity (1 - KS_D 0.894 vs 0.713), novelty (0.888 vs 0.770) and AbNatiV humanness (0.931 vs 0.769), while being roughly tied on sequence length (0.986 vs 0.9...
Table 1, page 9
1 - KS_D, the Kolmogorov-Smirnov distance between the property distribution of 10,000 generated sequences and that of held-out validation sequences; higher is better, 1.0 is a perfect match. No error bars, seeds or confidence intervals are reported.
Branching Flows vs. the authors' re-implementation of Edit Flows, same transformer backbone, same 15M-sequence training set, same batch size, optimiser and step count, same 1,000-step sampling and same 10,000 generated sequences. The 'Oracle length' DFM model, which is told the true length, is the reference ceiling rat...
Re-training both models under the stated matched setup and regenerating 10,000 sequences each, Edit Flows reaches 1 - KS_D within run-to-run variation of Branching Flows on diversity, novelty and AbNatiV (i.e. the ~0.18 and ~0.16 gaps on diversity and AbNatiV largely vanish), or Branching Flows falls clearly behind on ...
table
Table 1: Distribution agreement (1 - KS_D, higher is better) between properties of samples from each model vs. validation sequences. From left to right: Sequence Length, Diversity (within-samples min Cosine distance), Novelty (minimum edit distance to true sequence), CDR3 length, and AbNatiV 'humanness' score. Histogra...
https://arxiv.org/abs/2511.09465
https://openreview.net/forum?id=4SxwSH1IQc
true
https://paperswithcode.co/paper/2511.09465
2511.11934
A Systematic Analysis of Out-of-Distribution Detection Under Representation and Training Paradigm Shifts
[ "Claudio César Claros-Olivares", "Austin Brockmeier" ]
poster
evaluations_datasets
standard
Out-of-distribution (OOD) detectors, or confidence scoring functions (CSFs), assign a score to each prediction so that unreliable inputs can be flagged. Rankings of these scores are unstable across datasets, architectures and training pipelines. The paper argues that which detector works depends mainly on the geometry ...
Projection filtering: fit PCA on the training-set penultimate-layer activations H of a trained classifier, keep the top-k eigenvectors P (k chosen by an explained-variance threshold tuned on an ID-only validation split), and replace each feature h by ĥ = P Pᵀ(h − µ) + µ before computing the CSF. 'Global' fits one P on ...
On VGG-13 (FD-Shifts setup), applying global PCA projection filtering to penultimate features before Mahalanobis scoring lowers AUGRC by a mean of 24.1 (median 16.6), winning 50 of 64 paired comparisons (Wilcoxon p < 0.001).
Table 15, page 34 (Appendix F); summarized in Section 4.3, page 8
AUGRC (lower is better; the paper does not state the scale, likely ×10³). ΔAUGRC = mean(base − variant) over paired source × OOD dataset × paradigm × run combinations; positive means the projected variant is better. Uncertainty is a two-sided Wilcoxon signed-rank p-value with win/loss counts; no std or CI is reported.
Mahalanobis on raw penultimate features vs. Mahalanobis on globally PCA-projected features, paired over the same source × OOD dataset × paradigm × run combinations of VGG-13 with the same ID/OOD data; note that the training-time dropout setting is selected separately for each (CSF, projection variant) on validation AUG...
Re-training VGG-13 models on the FD-Shifts sources and evaluating Mahalanobis with and without global projection on the same OOD sets, the projected variant does not lower AUGRC in a clear majority of paired comparisons (e.g. win rate near 50% or a paired Wilcoxon test that is not significant), or the mean gain is near...
table
Table 15: Full paired AUGRC comparison: base CSF vs. projection variants on VGG-13 (Conv). ∆AUGRC = mean(base − variant); positive = variant better. Significant improvements (p < 0.05, variant better) are marked with ✓.
https://arxiv.org/abs/2511.11934
https://openreview.net/forum?id=xZm0LvUahe
true
https://paperswithcode.co/paper/2511.11934
2511.14259
ManipShield: A Unified Framework for Image Manipulation Detection, Localization and Explanation
[ "Zitong Xu", "Huiyu Duan", "Xiaoyu Wang", "Zhaolin Cai", "Kaiwei Zhang", "Xiongkuo Min", "Guangtao Zhai" ]
poster
main
harder
Modern instruction-driven image editors (FLUX-Kontext, NanoBanana, GPT-Image, SeedDream, Qwen-Image-Edit) produce realistic local and global edits that go well beyond face swaps. Existing image manipulation detection and localization (IMDL) datasets cover few editing models and categories and mostly give only real/fake...
ManipBench: 22K real photos are edited by 25 editing models across 12 manipulation categories (add, remove, replace, color, background, size, action, material, expression, three kinds of text), giving about 455K manipulated images; 100K of them get human bounding boxes, judgment cues and textual explanations. Images ar...
On the ManipBench test split, ManipShield reaches 94.66% overall real/manipulated detection accuracy versus 92.58% for the best fine-tuned baseline (Qwen3-VL-8B) and 92.46% for fine-tuned AIDE, and on every held-out proprietary editor it beats all fine-tuned baselines (e.g. 81.45% vs 76.61% best baseline on FLUX-Kontex...
Table 2, page 7
Detection accuracy and F1 (%, higher is better) at threshold 0.5. Single run; no standard deviations, seeds or confidence intervals are reported.
ManipShield (fine-tuned InternVL3.5-8B with contrastive vision LoRA, LDS layer selection and task decoders) vs. fine-tuned baselines trained on the same split: ResNet50, Swin-T, MVSSNet, PSCCNet, HifiNet, FakeShield, CNNSpot, Lagrad, Univ, AIDE, DeepSeekVL2-small, InternVL3-8B, Qwen3-VL-8B. Zero-shot rows are reported ...
With matched training on ManipBench, a fine-tuned baseline (in particular Qwen3-VL-8B, InternVL3-8B or AIDE) matches or exceeds ManipShield's overall accuracy, or ManipShield does not beat the best fine-tuned baseline on the out-of-distribution editors (FLUX-Kontext, NanoBanana, GPT-Image, SeedDream4).
table
Table 2: Comparison results on different manipulation methods. ♠ standard CNN/Transformer baselines, ♡ image manipulation detection methods, ♣ AI-generated image detection methods, ♢ multimodal large language models. The fine-tuned results are marked with ✻. The best results are highlighted in red, and the second-best ...
https://arxiv.org/abs/2511.14259
https://openreview.net/forum?id=umrmVI1xvK
true
https://paperswithcode.co/paper/2511.14259
2511.15856
GLOBE: Accurate Surrogates for Boundary-Driven PDEs via Domain-Inspired Architectures and Equivariance
[ "Peter Sharpe" ]
poster
main
harder
Steady RANS simulations of aerodynamic flows are expensive, so ML surrogates that predict flow fields from geometry are widely studied. Many such surrogates do not enforce basic physical structure: they break under rotation or reflection, depend on mesh discretization or units, or use local receptive fields even though...
GLOBE represents output fields at arbitrary query points as an area-weighted sum over boundary faces of a learned kernel K(source face -> target point). The kernel uses only relative positions nondimensionalized by reference lengths. It builds rotation-invariant features (smoothlog magnitudes, Legendre polynomials of p...
On the AirFRANS Scarce split (200 training cases), GLOBE's normalized test MSE (×10^-2) is 0.0238 (u_x), 0.0148 (u_y), 0.0496 (p) and 0.1889 (surface p), versus 0.1520, 0.1130, 0.2400 and 2.7000 reported for MARIO, the best published surrogate, i.e. 4.8-14.3x lower on every field.
Table 2, page 9
Mean squared error on official AirFRANS Scarce test cases, normalized by training-set field variance (released AirFRANS evaluator); lower is better. Single-run point estimates, no error bars or seeds reported.
GLOBE (trained by the authors) vs. published values for MARIO, Transolver, MLP, GraphSAGE, PointNet and GUNet (copied from Catalani et al. 2025b and Bonnet et al. 2023, not rerun)
A GLOBE model trained on the 200 Scarce training cases and scored with the official AirFRANS evaluator does not beat MARIO's reported MSE on all four fields, or the margin shrinks to under ~2x on volume pressure (p).
table
Table 2: AirFRANS Scarce (low-data) task: mean squared error on the official test cases, normalized by the training-set field variance as in Table 1; lower is better. External values are as reported in the cited works (not rerun). GLOBE values are single-run point estimates.
https://arxiv.org/abs/2511.15856
https://openreview.net/forum?id=YvUcvzejJe
true
https://paperswithcode.co/paper/2511.15856
2511.17439
InTAct: Interval-based Task Activation Consolidation for Continual Learning
[ "Patryk Krukowski", "Jan Miksa", "Piotr Helm", "Jacek Tabor", "Paweł Wawrzyński", "Przemysław Spurek" ]
poster
main
standard
Continual learning asks a model to learn a sequence of tasks without forgetting earlier ones. In domain-incremental learning (DIL), every task has the same label set but a different input distribution, such as art styles or image corruptions. Prompt-based methods (L2P, DualPrompt, CODA-Prompt, KA-Prompt) keep a pre-tra...
After each task, InTAct records a per-dimension activation interval (the 5% and 95% quantiles, alpha = 0.95) of the representations of that task, both for the [CLS] feature and for the inputs to the affine layers of the classifier head. It merges these intervals into a cumulative axis-aligned hypercube by element-wise ...
On 15-task domain-incremental ImageNet-R with a frozen ViT-B/16, adding InTAct raises final average accuracy for every prompt method tested: CODA-Prompt from 61.21 ± 0.49 to 74.23 ± 0.16 (+13.0 p.p.), DualPrompt from 53.31 ± 0.36 to 61.85 ± 0.45 (+8.5 p.p.), and L2P from 50.34 ± 0.26 to 58.34 ± 0.24 (+8.0 p.p.).
Table 4, page 26 (Appendix K)
Average Accuracy (AA, %) over all tasks after training on the final task; higher is better. ± is the std over 5 independent runs (stated as an average over 5 runs; the paper does not say whether ± is std or SE).
Each prompt-based method (L2P, DualPrompt, CODA-Prompt) vs. the same method + InTAct, all run in the same CODA-Prompt codebase with the same backbone, task splits and baseline hyperparameters.
On ImageNet-R, CODA-Prompt + InTAct does not beat plain CODA-Prompt by clearly more than the run-to-run std (e.g., the gain is under about 3 p.p.), or InTAct gives no consistent gain for L2P and DualPrompt under matched settings.
table
Table 4: Performance results of integrating InTAct with L2P, DualPrompt, and CODA-Prompt. We report AA for ImageNet-R and DomainNet in the DIL setting. Incorporating InTAct consistently yields performance gains over prompt-based baselines. Results are averaged over 5 independent runs.
https://arxiv.org/abs/2511.17439
https://openreview.net/forum?id=1YkQOLXLUU
true
https://paperswithcode.co/paper/2511.17439
2511.19706
Selective Disk Bispectrum: A Complete and Rotation Invariant Image Descriptor
[ "Adele Lantow", "Nina Miolane" ]
poster
main
standard
Many vision tasks (microscopy, aerial imagery, cryo-EM) need features that do not change when the image is rotated. Hand-crafted rotation invariants (Hu/Zernike moments, SIFT-like descriptors) are cheap but throw away phase information, so different images can share a descriptor; learned equivariant networks are discri...
An L x L image is masked to a disk and expanded in disk harmonics a_{n,k} (Bessel-function radial part times e^{in theta}), keeping coefficients with lambda_{nk} below the bandlimit pi*L/2. The SDB (Definition 1) keeps only b_{0,0,k} = a_{0,1}^2 a*_{0,k} and b_{2,n,k} = a_{1,1} a_{n,1} a*_{n+1,k} for n = 0..N_m-1, whic...
On rotated noisy MNIST (28x28, 50k-parameter MLP, test rotations disjoint from train rotations), an MLP on SDB features stays at roughly 0.85-0.70 test accuracy as noise variance rises from 0.1 to 0.4, while every convolution-based rotation-invariant baseline (pooled G-CNNs, Selective G-Bispectrum, G-Triple Correlation...
Figure 2 (panel a, MNIST, Image Size 28x28), page 8
test accuracy (higher is better), mean over 5 seeds with std shaded; values are read off the plot and approximate
SDB + MLP vs. G-CNN max pool, G-CNN avg pool, Selective G-Bispectrum, G-Triple Correlation (trained end-to-end with the same MLP), and frozen DINOv3 / EVA-02 / OpenCLIP features + the same MLP budget
On rotated MNIST 28x28 with a 50k-parameter MLP and the 0-90 / 90-180 degree train/test split, SDB accuracy at sigma^2 in {0.1, 0.2, 0.4} is not at least 0.3 higher than the best convolution-based baseline, or at sigma^2 = 0.4 SDB does not exceed the best frozen-transformer feature by more than the seed std.
figure
Figure 2: Classification results on rotated noisy MNIST (left) and FashionMNIST (right). The SDB and transformers outperform convolution-based methods on noisy rotated images, across (a) image size (shown for 50,000 parameter MLP) and (b) MLP parameter budgets (shown for image size 28x28). Mean is reported across seeds...
https://arxiv.org/abs/2511.19706
https://openreview.net/forum?id=ZBFrV7kiwX
true
https://paperswithcode.co/paper/2511.19706
2511.21075
Aligning LLMs with Biomedical Knowledge using Balanced Fine-Tuning
[ "Zhenchao Tang", "Fang Wang", "Haohuai He", "Jiale Zhou", "Tianxu Lv", "Jun Zhu", "Shou Z Chen", "Minghao Yang", "Yu Wang", "Jiayang Wu", "Yidong Song", "Yaokun Li", "Jiehui Huang", "Jun Zhou", "Bing He", "Jianhua Yao" ]
poster
main
harder
Post-training LLMs on biomedical text with standard supervised fine-tuning (SFT) gives every token equal weight, and Dynamic Fine-Tuning (DFT) down-weights each token by its own predicted probability to stabilize training. The authors argue that in biomedical text, low-confidence tokens often come in dense runs (rare e...
Balanced Fine-Tuning (BFT) changes only the per-token loss weights of SFT. For each response token t with confidence c_t = p(y_t | y_<t, x), it computes a local mean confidence C_loc over a centered window of g = 256 response tokens. The token weight is w_t = stopgrad(clip(c_t / (C_loc + eps), 0, 1)), so a low-confiden...
As the VCWorld backbone on chemical-perturbation reasoning (5 cell lines), DeepSeek-R1-Distill-Llama-70B fine-tuned with BFT reaches 0.70 average accuracy, vs. 0.56 for SFT and 0.49 for DFT under the same recipe. Over three fine-tuning seeds the averages are BFT 0.696/0.679/0.708 (SD 0.015) vs. SFT 0.562/0.541/0.578 (S...
Table 1, page 6 (seed variability: Table 6, page 18)
3-class (Up/Down/No) accuracy averaged over 5 held-out cell lines, higher is better. In Table 1, ± is SD over 8 stochastic inference passes of a single checkpoint (decoding variability only). Table 6 gives SD across 3 independent fine-tuning seeds.
BFT 70B vs. SFT 70B and DFT 70B (same data, optimizer and schedule; only the loss weights differ), with BFT-token and BFT-sample ablations; the original Gemini-2.5-Flash backbone is a reference
Under the shared recipe, BFT's VCWorld average accuracy is not clearly above SFT's: the gap is under ~0.05 (vs. the reported 0.134), or the seed ranges overlap. A smaller-scale check would also count against the claim if BFT fails to beat SFT on Llama-3.1-8B or Qwen2.5-14B (reported 0.52 vs 0.42 and 0.57 vs 0.47).
table
Table 1: Chemical perturbation reasoning accuracy for joint Up/Down/No classification. Upper block: original VCWorld; middle: aligned 70B replacements; lower: after GRPO. Cells are mean ± SD over eight stochastic inference passes of one checkpoint (decoding, not training, variability). Displayed averages are rounded to...
https://arxiv.org/abs/2511.21075
https://openreview.net/forum?id=p2HWge7bRt
true
https://paperswithcode.co/paper/2511.21075
2511.22688
Test-time Scaling of Diffusions with Flow Maps
[ "Amirmojtaba Sabour", "Michael Albergo", "Carles Domingo i Enrich", "Nicholas Boffi", "Sanja Fidler", "Karsten Kreis", "Eric Vanden-Eijnden" ]
poster
main
standard
A common way to make a pretrained diffusion or flow model produce samples that score highly under a user-specified reward is to add the reward's gradient to the generative dynamics. The reward is usually defined only on clean data at the end of generation, so during sampling it has to be evaluated on a guess of where t...
FMTT (Flow Map Trajectory Tilting) samples the reward-tilted distribution rho_1(x) exp(r(x)) / Z with the SDE dx_t = v_{t,t}(x_t) dt + eps_t [s_t(x_t) + grad r_t(x_t)] dt + sqrt(2 eps_t) dW_t, where v_{t,t} is the velocity implied by the flow map, s_t is the score derived from it, and the time-dependent reward is r_t(x...
In 2D SMC sampling of a ring distribution tilted toward a zigzag, flow-map look-ahead matches the tilted target far better than no look-ahead or denoiser look-ahead at every step count: MMD 0.043/0.065/0.065/0.031 vs. best baseline 0.996/0.460/3.016/3.459 and SW2 0.060/0.083/0.126/0.089 vs. 0.578/0.443/0.902/0.857 at 5...
Table 3 (Appendix D.1), page 30; summarized in Figure 5 and Section 3.4 of the main text
MMD and SW2 between SMC output and rejection-sampled tilted target (lower is better); number of resampling steps (lower = more stable weights). Single run per setting; no error bars reported.
Flow-map look-ahead vs. no look-ahead vs. 1-step denoiser look-ahead, same trained model, same SMC sampler, particles, schedule and stochasticity, at 50/100/200/500 steps
At any of the four step counts, the flow-map look-ahead's MMD or SW2 is not clearly lower (for example, within a factor of 2) than the better of the no-look-ahead and denoiser look-ahead baselines, or the flow-map variant needs a comparable number of resampling steps.
table
Table 3: Quantitative results for the 2D toy experiment. We compare no-lookahead, denoiser-lookahead, and flow map-lookahead across different numbers of SMC steps. Lower Maximum Mean Discrepancy (MMD) and Sliced Wasserstein-2 (SW2) indicate better agreement with the tilted target distribution.
https://arxiv.org/abs/2511.22688
https://openreview.net/forum?id=EtFrLaqiA4
true
https://paperswithcode.co/paper/2511.22688
2511.22991
Guiding Visual Autoregressive Models through Spectrum Weakening
[ "Chaoyang Wang", "Tianmeng Yang", "Yunhai Tong" ]
poster
main
harder
Visual autoregressive (AR) image generators usually rely on classifier-free guidance (CFG), which needs a trained unconditional branch and is undefined for unconditional generation. Diffusion models have alternatives that guide with a deliberately weakened copy of the model (e.g. perturbed attention, timestep or token ...
Spectrum Weakening Guidance (SWG) builds the weak branch from the same pretrained model at inference time. In selected modules (e.g. the attention Q/K/V representations), each token's feature vector is mapped with a DFT along the channel dimension, a binary diagonal mask keeps only a subset of the spectral components (...
For unconditional NOVA generation evaluated on COCO, guiding with the spectrally weakened model gives FID 104.51 (SWG-f) / 105.98 (SWG-s), better than the alternative weak branches built by layer pruning (110.87) or feature averaging (112.79), and far better than no guidance (139.75).
Table 3, page 10
FID (lower is better) against COCO; also IS and LAION aesthetic score (higher is better). Single numbers, no seeds, standard deviations or confidence intervals reported.
SWG-f and SWG-s vs. Avg-feature and layer-pruning weak-model guidance vs. no guidance, same NOVA model, unconditional generation
With a reasonable tuning of each method's guidance scale, SWG's unconditional FID on COCO is not lower than the layer-pruning weak branch's, or the gap is within the FID variation across sampling seeds.
table
Table 3: Comparison of unconditional generation on the COCO dataset. NOVA is used for evaluation. AS denotes aesthetic score. Bold indicates the best entries. SWG-s and SWG-f indicate spatial and spectral renormalization, respectively.
https://arxiv.org/abs/2511.22991
https://openreview.net/forum?id=PoNh97Mzdl
true
https://paperswithcode.co/paper/2511.22991
2512.00469
FairMT: Fairness for Heterogeneous Multi-Task Learning
[ "Guanyu Hu", "Tangzheng Lian", "Na Yan", "Dimitrios Kollias", "Xinyu Yang", "Oya Celiktutan", "Siyang Song", "Zeyu Fu" ]
poster
main
harder
Most work on algorithmic fairness considers one classification task at a time. Multi-task models that jointly predict detection, classification and regression outputs, often from datasets where each sample is labeled for only some tasks, have no common fairness objective. Standard MTL optimizers such as MGDA constrain ...
FairMT defines one-sided (asymmetric) per-task fairness violations: for binary detection, Asymmetric Equalized Odds penalizes only groups whose soft TPR falls below the best group's TPR or whose FPR rises above the lowest group's FPR (Eq. 1). Multi-class tasks use a class-wise version (Eq. 2) and regression uses Asymme...
On CelebA 29-attribute multi-task detection, FairMT reaches 88.4% (age) / 88.1% (gender) mean accuracy with EOD 3.4 / 6.4, versus MGDA's 87.7% with EOD 11.4 / 22.5, while the fairest baselines (UFaTE, MGDA-UFaTE) reach EOD 6.8 (age) and 12.2 (gender) only at 75-79% accuracy.
Table 1(a), page 7
Mean accuracy over the 29 attribute tasks (%, higher is better) and Equalized Odds / Equal Opportunity disparity across sensitive groups (%, lower is better); single numbers, no error bars or seeds reported
FairMT vs. MTL optimizers (MGDA, GradNorm), fairness-only methods (LNL, UFaTE) and hybrids (MGDA-Mean, MGDA-UFaTE), separately for age and gender as the sensitive attribute
Re-run on CelebA, FairMT's age EOD is not clearly below the best baseline's (6.8) or its gender EOD is not clearly below 12.2, or its mean accuracy falls more than about 1 point below MGDA's.
table
Table 1. Comparison of FairMT with multi-task (†), fairness-only (*), and hybrid fair-MTL (†*) baselines. Utility metrics (Acc, F1, CCC) are denoted with ↑ (higher is better), while fairness metrics (EOD, EO, KS, CSP) are denoted with ↓ (lower is fairer). (a) Attribute Detection (in %).
https://arxiv.org/abs/2512.00469
https://openreview.net/forum?id=y4pCWEetw2
true
https://paperswithcode.co/paper/2512.00469
2512.01707
StreamGaze: Gaze-Guided Temporal Reasoning and Proactive Understanding in Streaming Videos
[ "Daeun Lee", "Subhojyoti Mukherjee", "Branislav Kveton", "Ryan Rossi", "Viet Lai", "David Seunghyun Yoon", "Trung Bui", "Franck Dernoncourt", "Mohit Bansal" ]
poster
evaluations_datasets
harder
Streaming video assistants (for example on AR glasses) must answer questions using only frames seen so far, and sometimes must decide on their own when to speak. Human eye gaze is a strong signal of what a user is attending to and what they will do next, but existing streaming video benchmarks ignore gaze, and existing...
The authors take egocentric videos with eye tracking from EGTEA+, EgoExoLearn and HoloAssist, extract fixations from the raw gaze (spatial-dispersion and minimum-duration thresholds plus a scene-consistency check), and use InternVL3.5-38B to list objects inside and outside a circular field-of-view around each fixation....
On StreamGaze with visual gaze prompting, every evaluated MLLM scores far below humans: the best open-source model, Qwen2.5-VL-7B, reaches 0.478 overall accuracy and the best model overall (Claude Opus 4.8) 0.598, versus 0.827 for humans; humans lead on every one of the 10 tasks.
Table 2, page 8
Accuracy (higher is better), per task and averaged over the 10 tasks (Overall); multiple-choice exact match for past/present tasks, per-checkpoint yes/no accuracy for proactive tasks. No ± reported (single run).
Human performance vs. 8 closed-source MLLMs, AssistGaze, 7 open-source MLLMs and 5 streaming MLLMs, all zero-shot under the same causal protocol and gaze overlay.
Running Qwen2.5-VL-7B (or another open 7-8B model in Table 2) with the paper's protocol and gaze overlay gives Overall accuracy far from the reported value (e.g. above ~0.6, closing more than half the gap to 0.827), or a re-measured human score on a sample of questions is close to the model scores.
table
Table 2: Comparison of various MLLMs across StreamGaze tasks. We evaluate four categories of models, reporting accuracy for past, present and proactive tasks. Each section is sorted by overall performance, and the best per task across all models (excluding Human) is bolded.
https://arxiv.org/abs/2512.01707
https://openreview.net/forum?id=5OWuaFLDP6
true
https://paperswithcode.co/paper/2512.01707
2512.05024
Model-Free Assessment of Simulator Fidelity via Quantile Curves
[ "Yu-Shiou Lin", "Kaizheng Wang", "Garud Iyengar" ]
poster
main
harder
Generative models, especially LLMs, are increasingly used as simulators of real systems, for example to stand in for human survey respondents. How far a simulator is from reality changes from one scenario (such as a survey question) to the next. Both the real and the simulated output distributions for each scenario are...
For each scenario j, the method builds a gamma_j confidence set C_j around the real-world plug-in estimate p̂_j from n_j human samples. It then takes the pseudo-discrepancy Δ̂_j = sup_{u in C_j} L(u, q̂_j), where q̂_j is the simulator estimate from k samples. V̂_m(τ) is the empirical τ-quantile of {Δ̂_j}. The calibrate...
On 235 WorldValueBench questions with GPT-4o (k=200), adaptive-coverage calibrated quantile curves stay above the oracle curve at all τ. For n_j >= 500 they are close to it (at τ=0.5, about 0.07-0.11 vs. oracle about 0.04; n_j=50 gives about 0.34). With fixed γ_j=1/2, a clear gap remains even at n_j=5000: the curve is ...
Figures 5 and 6, page 14
Calibrated quantile value V̂ (squared error of the mean response on the [-1, 1] scale) as a function of quantile level τ; lower and closer to the oracle curve is tighter. It must not fall below the oracle curve. Single run, no error bars or repeated subsamples reported.
Calibrated curves at n_j in {50, 500, 1000, 5000} vs. oracle quantile curve (full-population p_j); adaptive γ_j = 1 - n_j^(-1/3) (Fig. 5) vs. fixed γ_j = 1/2 (Fig. 6)
Any of these refutes the claim: the calibrated curve falls clearly below the oracle curve over a non-trivial range of τ for some n_j; with adaptive γ_j at n_j >= 500 the curve stays as far from the oracle as the n_j = 50 curve; or fixed γ_j = 1/2 at n_j = 5000 is as tight as adaptive γ_j (no persistent gap at low τ).
figure
Figure 5: Tightness analysis for varying n_j under GPT-4o. The dotted black curve is the oracle quantile curve Δ*; the colored curves are calibrated curves computed from subsamples with n_j = 50 (blue), n_j = 500 (orange), n_j = 1000 (green), and n_j = 5000 (red). The corresponding adaptive average coverage levels show...
https://arxiv.org/abs/2512.05024
https://openreview.net/forum?id=GwnlXWrqUF
true
https://paperswithcode.co/paper/2512.05024
2512.05325
LYNX: Learning Dynamic Exits for Confidence-Controlled Reasoning
[ "Ömer Faruk Akgül", "Yusuf H Kalayci", "Rajgopal Kannan", "Willie Neiswanger", "Viktor Prasanna" ]
poster
main
harder
Reasoning LLMs such as DeepSeek-R1 often keep generating chain-of-thought after they already have the answer. This wastes inference compute and sometimes talks the model out of a correct answer. Early-exit methods try to stop the reasoning once it is sufficient. Existing methods use token-entropy heuristics (DEER), ext...
LYNX considers exiting only at naturally occurring cue tokens ('hmm', 'wait', 'alternatively') inside the <think> block. To get training labels, the authors run one CoT rollout per Hendrycks MATH problem at T = 0.6. At each cue they force an exit: they cut the CoT before the cue, append '</think> Final Answer: \boxed{'...
On GSM8K (1,319 test problems, T = 0.0) with DeepSeek-R1-Distill-Qwen-1.5B, LYNX at c = 0.90 reaches 78.70% accuracy with 792 average generated tokens (-54.8% vs. baseline). DEER reaches 69.14% with 716 tokens (-59.1%), and the vanilla CoT baseline reaches 75.97% with 1,751 tokens. LYNX is about 9.6 points more accurat...
Table 2, page 13
Pass@1 accuracy (higher is better) and mean generated tokens per question (lower is better); a single greedy (T = 0.0) run, no error bars or seeds reported. The '∆ vs base' accuracy column is a relative change in %, not percentage points.
LYNX (c = 0.90, probe trained and calibrated on Hendrycks MATH) vs. DEER and vanilla CoT on the same model, prompts, decoding settings and 13k-token cap; ToN (67.93%, 893 tokens) is a weaker secondary baseline.
Re-running GSM8K with DeepSeek-R1-Distill-Qwen-1.5B at T = 0.0, LYNX at a confidence level with token savings similar to DEER (about 50-60%) is not clearly more accurate than DEER (e.g. the gap is under ~3 points), or LYNX's accuracy falls clearly below the full-CoT baseline at that operating point.
table
Table 2: Accuracy–efficiency tradeoffs at temperature T = 0.0 for DeepSeek-R1-Distill-Qwen-1.5B and QwQ-32B. For each dataset we report vanilla chain-of-thought (Baseline), DEER, Think-or-Not (ToN), and LYNX for multiple confidence levels c. ∆Acc vs base and ∆Tokens vs base are relative changes (%) with respect to each...
https://arxiv.org/abs/2512.05325
https://openreview.net/forum?id=rSKYIHN4OX
true
https://paperswithcode.co/paper/2512.05325
2512.06776
From Next-Token to Next-Block: A Principled Adaptation Path for Diffusion LLMs
[ "Yuchuan Tian", "Yuchen Liang", "Shuo Zhang", "Yingte Shu", "Guangwen Yang", "Wei He", "Sibo Fang", "Tianyu Guo", "Kai Han", "Chao Xu", "Hanting Chen", "Xinghao Chen", "Yunhe Wang" ]
spotlight
main
harder
Diffusion language models (DLMs) can decode several tokens in parallel, but training them from scratch is expensive. A shortcut is to start from an off-the-shelf autoregressive (AR) LLM and adapt its weights into a DLM. Earlier adaptations either moved to full-sequence diffusion by randomly annealing the attention mask...
The model is trained as a block-diffusion LM with a parallel recipe: a noised copy of the sequence is concatenated with the clean sequence, and a structured 2L x 2L mask lets each noised block attend bidirectionally within itself and to all earlier clean blocks, while the clean copy never reads the noised copy. The mas...
When adapting an AR LLM into a block-diffusion model (block size 32) for 2000 iterations, keeping the context strictly causal (Context-Causal) yields an average of 48.6 over GSM8K/MATH/HumanEval/MBPP vs. 31.4 for Block-Causal, winning every benchmark (GSM8K 68.8 vs. 60.1, MATH 36.8 vs. 1.6, HumanEval 41.5 vs. 24.4, MBP...
Table 1, page 5
Benchmark accuracy / pass@1 (%), higher is better; single runs, no error bars reported
Context-Causal vs. Block-Causal context attention, same AR initialization and 2000-iteration adaptation budget
Under matched adaptation from the same AR checkpoint, Context-Causal does not beat Block-Causal on average across the four benchmarks by a clear margin (e.g., under ~5 points), or Block-Causal does not collapse on MATH relative to Context-Causal.
table
Table 1: Comparison of Block-Causal and Context-Causal attention schemes. Context-Causal gains a clear advantage in adaptation from AR.
https://arxiv.org/abs/2512.06776
https://openreview.net/forum?id=VLjkAcK9fS
true
https://paperswithcode.co/paper/2512.06776
2512.12602
Exact Flow Linear Attention: Exact Solution from Continuous-Time Dynamics
[ "Jingdi Lei", "Di Zhang", "Soujanya Poria" ]
spotlight
main
standard
Delta-rule linear attention (DeltaNet and its gated variants) keeps a matrix-valued memory that is updated at each token by erasing the component along the current key and writing a new key-value pair, giving linear-time sequence models with chunkwise-parallel training. The update is usually motivated as one gradient s...
EFLA replaces the Euler step with the exact solution of the ODE dS/dt = -k k^T S + k v^T over one interval of length beta. Because k k^T is rank 1, the matrix exponential and the input integral collapse to closed form: S_t = (I - alpha_t k_t k_t^T) S_{t-1} + alpha_t k_t v_t^T, with alpha_t = (1 - exp(-beta_t lambda_t))...
On pixel-level sequential MNIST with a d=64 linear-attention classifier and matched learning rate 1e-3, EFLA and DeltaNet both reach about 92% clean accuracy. Under input intensity scaling, EFLA keeps about 58% at scale 3 and 45% at scale 10, while DeltaNet drops to about 23% and 20%. Under additive Gaussian noise with...
Figure 1 (top row), page 7
Test classification accuracy (%) under perturbation, higher is better; single run, no error bars reported
EFLA update vs. DeltaNet (Euler) update in the same sMNIST linear-attention classifier at the same learning rate (1e-3), across perturbation strength for pixel dropout, intensity scaling and Gaussian noise
With matched architecture, training and learning rate, EFLA's accuracy under intensity scaling (scale >= 3) or Gaussian noise (std 0.2) is not at least ~15 points higher than DeltaNet's when averaged over several seeds, or the gap is within seed-to-seed spread.
figure
Figure 1: EFLA outperforms DeltaNet in both convergence speed and robustness on sMNIST. The plots illustrate training dynamics and robustness against dropout, intensity scaling, and additive Gaussian noise. EFLA maintains higher accuracy as perturbation intensity increases, especially under the larger learning-rate set...
https://arxiv.org/abs/2512.12602
https://openreview.net/forum?id=GOjRwLmiSD
true
https://paperswithcode.co/paper/2512.12602
2512.13607
Nemotron-Cascade: Scaling Cascaded Reinforcement Learning for General-Purpose Reasoning Models
[ "Boxin Wang", "Chankyu Lee", "Nayeon Lee", "Sheng-Chieh Lin", "Wenliang Dai", "Yang Chen", "Yangyi Chen", "Zhuolin Yang", "Zihan Liu", "Mohammad Shoeybi", "Bryan Catanzaro", "Wei Ping" ]
oral
main
harder
Post-training general-purpose reasoning LLMs with reinforcement learning usually mixes prompts from many domains (chat alignment, instruction following, math, competitive coding, software engineering) in one RL run. These domains differ a lot in response length and in how slow it is to check an answer (a rule-based mat...
Starting from Qwen3-8B-Base and Qwen3-14B-Base, the authors run two-stage SFT (16K then 32K tokens) on responses mostly generated by DeepSeek-R1-0528 / DeepSeek-V3-0324, giving an 8B unified model (switches between thinking and non-thinking with /think and /no_think flags per user turn) and 8B/14B thinking-only models....
After the full Cascade RL pipeline, the unified Nemotron-Cascade-8B scores 71.1 pass@1 (avg@8, thinking mode, 64K budget) on LiveCodeBench v6 (08/24-05/25), up 14.4 points from its own SFT checkpoint (56.7) and above Qwen3-8B (58.3, official); on AIME 2025 it scores 80.1 vs. 72.8 for its SFT checkpoint and 67.3 for Qwe...
Table 1, page 7 (SFT baseline from Table 2, page 14; final per-stage numbers in Table 8, page 28)
pass@1 accuracy (%), higher is better, averaged over k samples per problem (avg@8 for LiveCodeBench, avg@64 for AIME); no standard deviations, seeds or confidence intervals are reported
Nemotron-Cascade-8B after Cascade RL vs. the same model's SFT checkpoint (authors' run, same evaluation) and vs. Qwen3-8B in thinking mode (officially reported numbers, not re-run by the authors)
Evaluating the released Nemotron-Cascade-8B under the paper's settings (thinking mode, 64K tokens, temperature 0.6, top-p 0.95, avg@8) on LiveCodeBench v6 08/24-05/25 gives clearly less than ~68, or Qwen3-8B evaluated with the same harness comes within a few points of it.
table
Table 1: Main results. For unified reasoning models, we report reasoning-related benchmark results in thinking mode. For IFEval and IFBench, we report the higher score obtained from either thinking or non-thinking mode. LCB stands for LiveCodeBench. When comparing with our inital SFT models in Table 2, ↑number indicate...
https://arxiv.org/abs/2512.13607
https://openreview.net/forum?id=96v36aMNTx
true
https://paperswithcode.co/paper/2512.13607
2512.15493
Soft geometric inductive bias for object centric dynamics
[ "Hampus Linander", "Conor Heins", "Marco Perin", "Alexander Tschanz", "Christopher L Buckley" ]
poster
main
standard
Learned world models of moving objects benefit from geometric priors, and strictly equivariant architectures (e.g. the Geometric Algebra Transformer) build exact rotation/translation symmetry into the network. Real environments often break those symmetries (walls, gravity, confining potentials, road layouts), and a har...
Each object's state is embedded as multivectors of a projective geometric algebra (Cl(3,0,1) in 3D: position as x e1 + y e2 + z e3 + e0, velocity as vx e1 + vy e2 + vz e3, charge as a scalar). An autoregressive transformer predicts the next state of all objects; every token is one object at one timestep, attention uses...
On 3D charged particles under harmonic confinement, the equivariant E-CliffordTransformer's rollout RMSE rises from ~0.19 (k_z = 0) to ~0.39 (k_z = 3) while the soft S-CliffordTransformer stays at ~0.19-0.25, so at k_z = 3 the soft model's RMSE is about half the equivariant model's; under constant gravity the soft mode...
Figure 6, page 9
Rollout RMSE against the ground-truth simulator (lower is better). Right panel: lines with shaded bands, left panel: box plots, presumably over seeds; the paper does not define the bands or state the number of seeds. Values are read off the plot and approximate.
S-CliffordTransformer vs. E-CliffordTransformer (strictly equivariant), parameter-matched Transformer, and MLP, trained on the same simulated data for each confinement strength / gravity setting
Re-training at k_z = 3, the E-CliffordTransformer's rollout RMSE is not clearly higher than the S-CliffordTransformer's (e.g. the gap is under ~0.1 or within seed spread), or E-CliffordTransformer degrades no more from k_z = 0 to k_z = 3 than S-CliffordTransformer does; or under gravity along z the Transformer matches ...
figure
Figure 6: Symmetry-breaking ablations. Left: constant gravity along z. Right: harmonic confinement F_z = -k_z z with increasing strength. The soft S-CliffordTransformer maintains robust performance as symmetry breaking increases, while the equivariant E-CliffordTransformer degrades under strong harmonic confinement.
https://arxiv.org/abs/2512.15493
https://openreview.net/forum?id=7yVfU7Zd4x
true
https://paperswithcode.co/paper/2512.15493
2512.15984
Lifting Biomolecular Data Acquisition
[ "Eli N. Weinstein", "Andrei Slabodkin", "Mattia G Gollub", "Kerry Dobbs", "Xiao-Bing Cui", "Fang zhang", "Kristina Gurung", "Elizabeth B Wood" ]
poster
main
standard
Learning a map from protein sequence to activity normally means synthesizing and testing one sequence at a time, so the information gained is bottlenecked by how many (sequence, activity) pairs the lab can afford. The paper proposes increasing information density instead: deliver several different sequences into each c...
LIFT assumes the measured activity of a cell is the sum of the activities of the sequences it received: y_i ~ Noise(sum_j f_theta(x_ij), sigma), with the number of sequences per cell m_i drawn from a Poisson with mean equal to the multiplicity of infection (MOI) and each x_ij drawn from a generative library model p(x)....
On the synthetic CDRH3 benchmark with 2000 simulated cells per run, LIFT training's PR AUC rises with MOI from about 0.31 at MOI 0.10 to about 0.81 at MOI 30.0, while conventional training on the same simulated data falls from about 0.24 to a minimum of about 0.05 at MOI 9.59 and recovers only to about 0.31 at MOI 30.0...
Figure 2, page 5
PR AUC (higher is better) for predicting the binarized label f(x) > 10 on held-out sequences; shaded bands are standard error across 10 independent simulation repeats
LIFT (functional neural LASSO / LeaVS-corrected training on mixture datapoints) vs. conventional supervised training (same CNN, same negative binomial noise model, multi-sequence cells split into individual (x, y) pairs), both on identically generated synthetic datasets at each MOI
Conventional training matches or exceeds LIFT at high MOI (e.g. 9.59 or 30.0), or LIFT's PR AUC fails to increase with MOI, or the LIFT-conventional gap at high MOI falls within the standard error across simulation repeats.
figure
Figure 2. The predictive performance of LIFT training versus conventional training across different experimental designs, on synthetic data. Error bars are s.e. across independent simulations.
https://arxiv.org/abs/2512.15984
https://openreview.net/forum?id=FD6jyMD6pj
true
https://paperswithcode.co/paper/2512.15984
2512.22118
ProEdit: Inversion-based Editing From Prompts Done Right
[ "Zhi Ouyang", "Dian Zheng", "Xiao-Ming Wu", "Jian-Jian Jiang", "Kun-Yu Lin", "Jingke Meng", "Wei-Shi Zheng" ]
poster
main
harder
Training-free, inversion-based editing maps a source image (or video) back to noise with a flow model such as FLUX, then samples again with a target prompt. To keep the background and structure unchanged, these methods start from the inverted latent and inject source attention features (usually V, sometimes K) while sa...
ProEdit is a plug-in for flow-based inversion editors (RF-Solver, FireFlow, UniEdit) on FLUX.1-[dev] with 15 sampling steps. A mask M of the edited region is taken from the text-to-image attention map of the last Double block at the first inversion step, then dilated by one step. KV-mix: in all Double and Single blocks...
On the PIE-Bench color-editing category, adding ProEdit to RF-Solver (FLUX.1-dev) raises background SSIM (x100) from 80.21 to 86.63 and edited-region CLIP similarity from 20.86 to 22.88, and gives similar gains for FireFlow (80.14 -> 86.53 SSIM; 21.02 -> 22.55 edited CLIP).
Table 2, page 6
Background-preservation SSIM (x10^2, higher is better) on unedited regions; CLIP similarity for the whole image and the edited region (higher is better). Single run, no error bars or seeds reported.
RF-Solver vs. RF-Solver+ProEdit, FireFlow vs. FireFlow+ProEdit, UniEdit vs. UniEdit+ProEdit, all on FLUX.1-dev and the PIE-Bench color-editing subset
When RF-Solver and RF-Solver+ProEdit are run on the PIE-Bench color-change subset with the stated settings (delta=0.9, beta=0.25, 15 steps), ProEdit fails to improve both background SSIM and edited-region CLIP similarity by a margin larger than the variation across random seeds (e.g. edited CLIP gain well below ~2 poin...
table
Table 2. Quantitative comparison on Color Editing. The best and second-best results are shown in bold and underline.
https://arxiv.org/abs/2512.22118
https://openreview.net/forum?id=yr9AcyQrnt
true
https://paperswithcode.co/paper/2512.22118
2512.22545
Self-Rewarded Multimodal Coherent Reasoning Across Diverse Visual Domains
[ "jusheng zhang", "Ningyuan Liu", "Kaitong Cai", "Sidi Liu", "Ziliang Chen", "Wenhao Wang", "Keze Wang" ]
spotlight
main
harder
Multimodal LLMs often give the right final answer with reasoning that is incoherent or not grounded in the image, partly because RL alignment usually rewards only the final answer. This paper asks whether cheap, label-free signals computed from the model's own outputs (semantic and lexical agreement between reasoning a...
SR-MCR scores each sampled response with five normalized signals: Sentence-BERT (all-MiniLM-L6-v2) cosine similarity between each reasoning sentence and the answer, ROUGE-L between reasoning and answer, 1 minus the fraction of repeated bigrams, CLIP similarity between spaCy-extracted text mentions and DETR-detected ima...
Starting from Qwen2.5-VL-7B and using the same 5-term self-reward, online GRPO training (SR-MCR-7B) reaches 67.6% on MMMU-val versus 56.4% for offline best-of-4 rejection-sampling fine-tuning (base: 50.3%), and it is also ahead on MMBench (91.2 vs. 88.1), MME (94.5 vs. 91.2) and V*Bench (80.6 vs. 79.1).
Table 4, page 12 (appendix); SR-MCR-7B MMMU figure also in Table 1, page 5
Benchmark accuracy (%), higher is better; single run per model, no seeds, standard deviations or confidence intervals reported
SR-MCR-7B (online GRPO with the self-reward) vs. RFT-7B (best-of-4 under the same self-reward, then SFT) vs. untuned Qwen2.5-VL-7B
A reproduction of SR-MCR on Qwen2.5-VL-7B with the described reward and data does not beat a matched best-of-4 RFT baseline on MMMU-val by a clear margin (e.g. under 3 points), or SR-MCR-7B lands far below the claimed 67.6% on MMMU-val (e.g. within a few points of the 50.3% base).
table
Table 4. Necessity of Online Optimization. Comparison between the Base Model, Rejection Sampling Fine-Tuning (RFT), and our SR-MCR on the 7B scale. RFT uses the same 5-term reward to select the best-of-N (N = 4) samples for supervised training. SR-MCR significantly outperforms RFT, demonstrating the critical value of o...
https://arxiv.org/abs/2512.22545
https://openreview.net/forum?id=tMbUp1FMia
true
https://paperswithcode.co/paper/2512.22545
2512.22991
Fusion or Confusion? Multimodal Complexity Is Not All You Need
[ "Tillmann Rheude", "Roland Eils", "Benjamin Wild" ]
poster
main
standard
Multimodal learning papers keep proposing more complex fusion, encoder, head, missing-modality and gradient-balancing mechanisms and report gains over earlier methods. Those gains are hard to interpret because papers differ in data splits, hyperparameter tuning, initialization and optimizer, and often skip cross-valida...
SimBaMM is a simple late-fusion model. Each modality goes through its own encoder and a linear projection to a shared width d. The resulting tokens (one [CLS]-style token per modality in SimBaMM-CLS) form a sequence that a Transformer head processes, with an attention mask that hides missing modalities, followed by a l...
On CREMA-D under the corrected protocol (speaker-independent 5-fold CV, validation-based model selection, both methods tuned), the simple late-fusion baseline SimBaMM-CLS reaches multimodal 6-class accuracy 0.6723 ± 0.031, versus 0.6105 ± 0.029 for AUG. Under the original leaky protocol, AUG ranks above SimBaMM (about ...
Figure 5, page 8 (numbers for the corrected protocol from Table 5, page 21)
6-class accuracy (Acc6) on CREMA-D, higher is better; ± is the standard deviation over the 5 subject-wise cross-validation folds. The original-protocol bars have no error bars.
SimBaMM(-CLS) vs. AUG, each under the original OGM/AUG data protocol and under the corrected speaker-independent protocol; the video-only and audio-only accuracies of each method are also shown
Under speaker-independent 5-fold CV with validation-based model selection and comparable tuning for both methods, AUG's multimodal accuracy matches or exceeds SimBaMM-CLS (e.g. the gap is under 1 fold SD, or reversed). Alternatively, the ranking does not depend on the protocol, i.e. AUG is not ahead of SimBaMM under th...
figure
Figure 5: Case study on the CREMA-D dataset. Under a corrected data protocol with subject-independent splits and consistent hyperparameter tuning, the relative performance of methods changes.
https://arxiv.org/abs/2512.22991
https://openreview.net/forum?id=RtOPHuqmpj
true
https://paperswithcode.co/paper/2512.22991
2601.00452
Imitation from Observations with Trajectory-Level Generative Embeddings
[ "Yongtao Qu", "Shangzhe Li", "Weitong Zhang" ]
poster
main
standard
In offline imitation learning from observations (LfO), the agent gets a single expert demonstration that contains only states, no actions, plus a large unlabeled offline dataset that is mostly suboptimal. It must learn an expert-like policy without interacting with the environment. The leading methods (SMODICE, PW-DICE...
TGE trains a Diffuser-style temporal U-Net diffusion model (horizon H=32, 20 diffusion steps) on state-action segments from the offline dataset. The U-Net's downsampling half is treated as an encoder phi, and the clean-input embedding z = phi(tau, 0) is computed with the action dimensions masked, so states alone determ...
In the D4RL medium+few-expert offline LfO setting, TGE+ReBRAC reaches normalised scores of 97.24 ± 2.22 (hopper), 91.83 ± 0.80 (halfcheetah), 108.02 ± 0.76 (walker2d) and 130.23 ± 1.36 (ant). The best baseline in each task scores 61.97 ± 1.65 (TGE+IQL; best external baseline PW-DICE 56.79 ± 11.55), 66.07 ± 8.52 (DILO),...
Table 1, page 12
Normalised D4RL return (higher is better; 100 = D4RL expert reference), mean ± standard deviation over 5 random seeds
TGE+ReBRAC vs. Diffuser (BC), SMODICE, PW-DICE, DILO (and TGE+IQL), same offline dataset and same single state-only expert episode
On medium+few-expert halfcheetah (or another of the four MuJoCo tasks), a 5-seed TGE+ReBRAC run does not beat the best of SMODICE/PW-DICE/DILO by more than the combined seed std, e.g. halfcheetah TGE+ReBRAC under about 75 or DILO above about 85.
table
Table 1: Main Results. TGE (combined with IQL or ReBRAC, highlighted in cyan) is compared against state-of-the-art offline LfO baselines. The results demonstrate that TGE achieves superior performance. We report the mean and standard deviation for each result with five random seeds. The top-performing results and those...
https://arxiv.org/abs/2601.00452
https://openreview.net/forum?id=ZKbWAjL1zV
true
https://paperswithcode.co/paper/2601.00452
2601.01762
AlignDrive: Aligned Lateral-Longitudinal Planning for End-to-End Autonomous Driving
[ "Yanhao Wu", "Haoyang Zhang", "Fei He", "Rui Wu", "Yanhu Shan", "Congpei Qiu", "Liang Gao", "Wei Ke", "Tong Zhang" ]
poster
main
harder
End-to-end autonomous driving models map camera images directly to planned motion. Recent state-of-the-art planners (e.g. HiP-AD) split planning into a lateral task (a drive path of spatially spaced waypoints for steering) and a longitudinal task (time-spaced trajectory waypoints for speed) and decode them with indepen...
AlignDrive is a sparse, query-based camera-only driving model. A Drive Path Predictor first refines anchor-based drive-path, map and agent queries (deformable attention on multi-view image features, temporal and inter-task cross-attention) and outputs candidate drive paths (15 waypoints at 2 m spacing). A cascaded Long...
On Bench2Drive closed-loop evaluation, full AlignDrive (path-conditioned 1D displacement planning + planning-oriented augmentation) reaches Driving Score 89.07, Success Rate 73.18% and Collision Rate 11.4%, versus 83.21, 63.18% and 22.7% for the same model with parallel path/trajectory decoding (Variant A).
Table 5, page 9
Bench2Drive Driving Score (higher better), Success Rate % (higher better), Collision Rate % = share of routes with a collision with a dynamic vehicle (lower better). Single run per variant, no error bars; Table 9 (p. 17) gives 3 simulator runs of the full model: DS 89.07 / 87.80 / 88.05 (mean 88.30), SR 73.18 / 71.36 /...
Variant E (LP + DP + DA, full AlignDrive) vs. Variant A (parallel lateral and longitudinal heads, HiP-AD style), with intermediate variants B (LP), C (LP+DP), D (LP+DA)
A retrained full model and a retrained parallel Variant A, each evaluated over several CARLA runs, differ by less than about 2 Driving Score points or 4 Success Rate points (roughly the run-to-run spread in Table 9), or Variant A has a collision rate no higher than the full model.
table
Ablation study on AlignDrive components. LP: uses lateral path prediction to condition longitudinal planning; DP: formulates longitudinal planning as displacement regression along the drive path; DA: applies planning-oriented data augmentation
https://arxiv.org/abs/2601.01762
https://openreview.net/forum?id=VXtoyI6yEY
true
https://paperswithcode.co/paper/2601.01762
2601.01930
MCGI: Manifold-Consistent Graph Indexing for Billion-Scale Disk-Resident Vector Search
[ "Dongfang Zhao" ]
poster
main
standard
Disk-resident graph indexes such as DiskANN (Vamana) serve approximate nearest neighbor search over billions of vectors by keeping compressed (PQ) codes in RAM and reading full-precision vectors and adjacency lists from SSD during a beam search. Search cost is dominated by the number of disk reads per query, which is s...
MCGI keeps the standard DiskANN index and search engine and changes only the candidate-list size per query. After n0 = 24 expansions of the beam search, it computes five features from distances already computed: the log of an MLE (Hill) LID estimate over the exact distances of the k = 10 nearest expanded nodes, the sam...
On GIST1M at 95% Recall@10, MCGI's query-adaptive list issues 223.7 disk reads per query versus 272.7 for DiskANN's fixed list on the same R = 32 index (18% fewer), and 125.5 versus 146.7 on the R = 48 index (14% fewer), also fewer than PipeANN (268.3 and 143.8).
Table 2, page 10
Mean disk reads (graph node reads) per query at 95% Recall@10, lower is better, interpolated along each method's recall curve; QPS also reported. Single run per setting, no error bars or seeds reported.
MCGI vs. DiskANN fixed-list beam search on the identical Vamana index (same PQ codes, beam width, list grid); PipeANN on the same index files as a secondary baseline.
On a GIST1M Vamana index with R = 32 (or 48), the query-adaptive list, calibrated on disjoint queries as described, does not reduce mean disk reads per query at 95% Recall@10 by clearly more than a few percent relative to the fixed-list DiskANN search on the same index (e.g., under 5% reduction), or the reduction vanis...
table
Table 2: QPS and disk reads per query at 95% recall.
https://arxiv.org/abs/2601.01930
https://openreview.net/forum?id=W1gmNJGmgv
true
https://paperswithcode.co/paper/2601.01930
2601.04153
Diffusion-DRF: Free, Rich, and Differentiable Reward for Video Diffusion Fine-Tuning
[ "Yifan Wang", "Yanyu Li", "Guocheng Qian", "Sergey Tulyakov", "Yun Fu", "Anil Kag" ]
poster
main
harder
Post-training of text-to-video diffusion models usually relies on scalar rewards from reward models trained on human preference data (e.g. VideoAlign, PickScore) or on DPO/GRPO-style preference optimization. These rewards are costly to build, give only one global score per video, and are prone to reward hacking: qualit...
Diffusion-DRF fine-tunes the DiT of Wan2.1-1.3B-T2V (VAE, text encoder and VLM frozen) on 5,077 caption-video pairs from OpenVid-1M. Offline, a text LLM (Qwen2.5-7B) decomposes each caption into scene elements and writes one Yes/No question per dimension: text-video alignment (TA), physical fidelity (Phy) and visual qu...
Fine-tuning Wan2.1-1.3B-T2V with Diffusion-DRF (Qwen2.5-VL-7B critic) reaches VBench-2.0 Overall 55.38 (3 seeds: 55.44 ± 0.26), versus 53.55 for VideoAlign (the strongest prior-method baseline), 53.70 for the authors' own single-question Vanilla-DRF (7B) variant, and 52.99 for the base model.
Table 1, page 7 (seed variance in Section D.4, page 20)
VBench-2.0 Overall score (higher is better), best checkpoint per method. Table 1 values are single runs; ± is std over 3 seeds and is reported only for Diffusion-DRF (7B). Baselines have no error bars.
Diffusion-DRF (7B) vs. VideoAlign differentiable reward tuning (strongest prior-method baseline), plus Flow-DPO, Flow-GRPO, PickScore, Vanilla-DRF and the untuned base model, all fine-tuning Wan2.1-1.3B-T2V on the same 5K prompts.
Retraining under the paper's protocol (same base model, data and best-checkpoint selection) gives Diffusion-DRF a VBench-2.0 Overall no more than about 0.5 points above a VideoAlign-reward run, or below it.
table
Table 1: Quantitative results on VBench-2.0. In addition to the overall score, we report representative sub-dimension metrics closely related to text-video alignment and physical fidelity. The best results are highlighted in bold, and the second best are underlined. For completeness, we evaluate Diffusion-DRF with thre...
https://arxiv.org/abs/2601.04153
https://openreview.net/forum?id=izqmMvuObQ
true
https://paperswithcode.co/paper/2601.04153