Dataset Viewer
Auto-converted to Parquet Duplicate
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
End of preview. Expand in Data Studio

NeurIPS 2026 Papers · Claims to Reproduce

1046 NeurIPS 2026 papers, each with one key claim that an agent can try to reproduce or falsify. It powers the NeurIPS 2026 Papers Space for the ML Intern reproduction hackathon.

The papers were sourced from ai-conferences/NeurIPS2026.

Each row has:

  • Paper metadata: arxiv_id, title, authors, presentation (poster, spotlight or oral), track, links to arXiv, OpenReview and Papers with Code, and on_papers_with_code (1046 of 1046 papers are indexed there today).
  • Context: background and method, a short summary of the problem and approach.
  • The claim: claim, where it comes from in the paper (claim_source), the metric, what it is compared against (comparison), and the falsification_criterion: what result would count as falsifying it.
  • Evidence: image, the table or figure the claim is read from, with its caption.
  • difficulty: harder marks papers that look harder than most to reproduce.
from datasets import load_dataset
ds = load_dataset("Neurips-2026-MLIntern-Repro/papers", split="train")

The site/ folder holds the same data as small per-paper JSON files and images, which the Space loads directly.

The claims and summaries are condensed from the papers, so check them against the paper before relying on them. The images are excerpts from the papers and remain under their authors' licenses.

Downloads last month
345

Space using Neurips-2026-MLIntern-Repro/papers 1