custom_id stringlengths 10 10 | central_claim stringlengths 152 319 | claim_evidence stringlengths 237 383 | paper_kind stringclasses 1
value | mre_config stringlengths 123 367 | verified_links dict | signals dict | agent_task stringlengths 350 873 | h100_estimate dict | verification_status stringclasses 1
value | web_verification stringclasses 1
value | exit_reason stringclasses 1
value | h100_hours_estimate float64 0.01 12 | h100_estimate_basis stringlengths 357 817 | h100_band stringclasses 2
values | h100_recomputed_hours float64 0 2.56 ⌀ | h100_arithmetic_mismatch bool 2
classes | h100_needs_human_review bool 2
classes | score int64 0 3 | tier stringclasses 3
values | audited_h100_hours float64 0 12 | h100_hours_adjudicated bool 2
classes | selection_band stringclasses 2
values | split stringclasses 1
value | match_target unknown |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2506.09045 | MagCache achieves 2.10x-2.68x inference speedup on video diffusion models while preserving visual fidelity, significantly outperforming existing caching-based methods in LPIPS, SSIM, and PSNR metrics. | Table 1 reports MagCache-fast achieves 2.68x speedup on Wan 2.1 1.3B with LPIPS 0.1748, SSIM 0.7490, PSNR 21.54; CogVideoX shows 2.37x speedup with LPIPS 0.0787; Abstract states '2.10x-2.68x speedups on Open-Sora, CogVideoX, Wan 2.1, and HunyuanVideo' | empirical | Run MagCache-fast inference on Wan 2.1 1.3B T2V (480P, 81 frames) using K=4, delta=0.12, retention_ratio=0.2, single prompt from VBench, measure latency speedup vs baseline. | {
"paper_or_project": [
"https://zehong-ma.github.io/MagCache/",
"https://arxiv.org/abs/2506.09045"
],
"code": [
"https://github.com/Zehong-Ma/MagCache"
],
"dataset": [
"https://github.com/Zehong-Ma/MagCache/tree/main/eval/magcache/vbench"
],
"weights": [
"https://huggingface.co/zai-or... | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "GitHub search found official repository Zehong-Ma/MagCache (271 stars). Repo contains: videosys/ framework with CogVideoXPipeline, eval/magcache/ with evaluation scripts, MagCache4Wan2.1/, MagCache4HunyuanVideo/, MagCache4F... | Reproduce the MagCache speedup claim by: 1) Installing MagCache via 'pip install -e .' from github.com/Zehong-Ma/MagCache, 2) Cloning Wan 2.1 repo from github.com/Wan-Video/Wan2.1 and copying magcache_generate.py, 3) Running: python magcache_generate.py --task t2v-1.3B --size 832*480 --ckpt_dir ./Wan2.1-T2V-1.3B --prom... | {
"hours": 0.03,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "A800",
"wallclock_hours": 0.009,
"h100_equivalent_multiplier": 0.32,
"basis": "Paper reports CogVideoX 2B baseline 74.10s and MagCache 31.15s on single A800 GPU. Per-inference H100-hours = 1 GPU x (31.15s / 3600s) x 0.32 = ... | verified | available | natural | 0.03 | derived_from_config: Paper reports CogVideoX 2B baseline 74.10s and MagCache 31.15s on single A800 GPU. Per-inference H100-hours = 1 GPU x (31.15s / 3600s) x 0.32 = 0.0028. MRE with 10 total inferences (1 calibration + 1 baseline + 1 accelerated, repeated ~4 times for variance) = ~0.028 H100-hours, rounded to 0.03. Eng... | 0-8 | 0.00288 | true | true | 0 | Easy | 0.00288 | true | 0-8 | dev | {
"config": "Wan 2.1 1.3B T2V, K=4, delta=0.12, retention_ratio=0.2, 50 steps, 832x480 resolution",
"metric": "end-to-end latency speedup",
"value": "2.68x",
"scope": "Wan 2.1 1.3B T2V (single prompt from VBench)",
"match_bar_kind": "point_estimate"
} |
2507.02546 | MoGe-2 achieves accurate monocular geometry estimation with metric scale and sharp details by decoupling relative geometry recovery from global scale prediction, outperforming existing methods in both geometric accuracy and metric scale estimation. | Abstract states: 'MoGe-2 achieves superior performance in accurate geometry, precise metric scale and visual sharpness.' Table 1 shows MoGe-2 achieves avg rank 2.05 for relative geometry and avg rank 1.95 for metric geometry; Table 2 shows MoGe-2 achieves boundary F1 rank 1.75, all outperforming baseline methods includ... | empirical | Load pretrained Ruicheng/moge-2-vitl from Hugging Face, run inference on NYUv2 test set using the moge infer CLI (moge infer -i NYUv2_images --o output --maps), measure metric point map relative error (Rel^p) against ground truth. | {
"paper_or_project": [
"https://wangrc.site/MoGe2Page/",
"https://arxiv.org/abs/2507.02546"
],
"code": [
"https://github.com/microsoft/MoGe"
],
"dataset": [],
"weights": [
"https://huggingface.co/Ruicheng/moge-2-vitl",
"https://huggingface.co/Ruicheng/moge-2-vitl-normal"
]
} | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "Official Microsoft MoGe repo (microsoft/MoGe) confirmed via github_repo tool. Contains complete implementation: moge/model/v2.py (MoGe-2 model), moge/scripts/infer.py (inference), moge/scripts/train.py (training), moge/test... | Clone https://github.com/microsoft/MoGe, install dependencies with 'pip install git+https://github.com/microsoft/MoGe.git', load the pretrained MoGe-2 model via 'from moge.model.v2 import MoGeModel; model = MoGeModel.from_pretrained("Ruicheng/moge-2-vitl")', run inference on NYUv2 test images using 'moge infer -i NYUv2... | {
"hours": 0.006,
"basis_kind": "paper_reported",
"gpu_count": 1,
"gpu_type": "A100 80GB",
"wallclock_hours": 0.01875,
"h100_equivalent_multiplier": 0.32,
"basis": "MRE is inference-only (no training required). README states 'Achieves 60ms latency per image (A100 or RTX3090, FP16, ViT-L)'. For evaluating ... | verified | available | natural | 0.006 | paper_reported: MRE is inference-only (no training required). README states 'Achieves 60ms latency per image (A100 or RTX3090, FP16, ViT-L)'. For evaluating on ~1000 images (reasonable sample for metric verification): 1000 images * 60ms * (1/3600) = 0.0167 hours base, adjusted for A100->H100 equivalence: 0.0167 * 0.32 ... | 0-8 | 0.006 | false | false | 0 | Easy | 0.006 | false | 0-8 | dev | {
"config": "MoGe-2 ViT-Large, pretrained Ruicheng/moge-2-vitl, inference on NYUv2 test set, 2500 tokens, FP16",
"metric": "Metric point map relative error (Rel^p, %)",
"value": "4.44%",
"scope": "NYUv2 test set",
"match_bar_kind": "threshold"
} |
2510.21323 | VL-SAE trains a unified sparse autoencoder across VLMs to extract shared vision-language concepts, enabling interpretation and enhancement of alignment. | Abstract: 'we propose VL-SAE, which first constructs a unified concept set by training a shared sparse autoencoder across diverse VLMs.' Table/Figure evidence: concept visualization quality and quantitative intra/inter-similarity scores. | empirical | OpenCLIP-ViT-B/32 VL-SAE, K=256, L=8, trained on CC3M image-text representations (activation collection then SAE training). | {
"paper_or_project": [
"https://github.com/ssfgunner/VL-SAE",
"https://arxiv.org/abs/2510.21323"
],
"code": [
"https://github.com/ssfgunner/VL-SAE",
"https://github.com/ssfgunner/VL-SAE/tree/main/cvlms/sae_trainer",
"https://github.com/ssfgunner/VL-SAE/tree/main/cvlms/eval",
"https://gith... | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "GitHub repo ssfgunner/VL-SAE verified via github_repo and github_repository_tree. Contains complete MRE-relevant code: training (cvlms/sae_trainer/train.py, sae_model.py, train.sh), evaluation (cvlms/eval/eval.py, visualize... | Reproduce the VL-SAE unified concept extraction on OpenCLIP-ViT-B/32 using CC3M: (1) download CC3M from huggingface.co/datasets/pixparse/cc3m-wds and run the preprocessing scripts; (2) collect hidden representations using the activation collector on OpenCLIP pretrained weights; (3) train VL-SAE with K=256, L=8 using th... | {
"hours": 0.006,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "RTX 4090",
"wallclock_hours": 0.037,
"h100_equivalent_multiplier": 0.15,
"basis": "RTX 4090 FP16 ~0.15x H100-equivalent (A100 80GB is 0.32x, RTX 4090 is ~47% of A100). Paper Appendix Table A6 reports OpenCLIP-ViT-B/16 trai... | verified | available | natural | 0.006 | derived_from_config: RTX 4090 FP16 ~0.15x H100-equivalent (A100 80GB is 0.32x, RTX 4090 is ~47% of A100). Paper Appendix Table A6 reports OpenCLIP-ViT-B/16 training at 132s on single RTX 4090 (0.03G FLOPs). OpenCLIP-ViT-B/32 is smaller, training ~100-120s. Using pre-trained weights for MRE eliminates training, requirin... | 0-8 | 0.00555 | false | false | 0 | Easy | 0.006 | false | 0-8 | dev | {
"config": "OpenCLIP-ViT-B/32, 256 concepts, L=8, CC3M",
"metric": "Unified concept extraction quality",
"value": "Unified concept set shared across VLMs",
"scope": "Concept visualizations and intra/inter-similarity scores on CC3M-derived concept images",
"match_bar_kind": "point_estimate"
} |
2505.18513 | AirRep achieves LDS (Linear Datamodeling Score) of 21.11 on FLAN, outperforming baseline representation methods (GTE-Small: 0.92) and competitive gradient-based methods (LoGra: 19.75) while being ~80x more computationally efficient. | Abstract states 'AirRep achieves performance on par with state-of-the-art gradient-based approaches while being nearly two orders of magnitude more efficient at inference time.' Table 2 (tab:lds-flan) shows AirRep LDS of 21.11 on FLAN vs GTE-Small's 0.92 and LoGra's 19.75. | empirical | Use the released AirRep-Flan-Small model from HuggingFace to encode FLAN training data (100K examples) and test data (6,520 examples), compute similarity scores with softmax attention aggregation, and evaluate LDS Spearman correlation using the provided evaluation script scripts/04_evaluate.py against pre-computed grou... | {
"paper_or_project": [
"https://arxiv.org/abs/2505.18513",
"https://github.com/sunnweiwei/AirRep"
],
"code": [
"https://github.com/sunnweiwei/AirRep"
],
"dataset": [
"https://huggingface.co/datasets/sunweiwei/airrep-test",
"https://huggingface.co/datasets/Muennighoff/flan"
],
"weights... | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "GitHub repo sunnweiwei/AirRep verified via github_repo and github_repository_tree. Contains airrep/ package (modeling_airrep.py, airrep_trainer.py, sft_trainer.py, data_sampler.py, __init__.py), fast_if/ package (LoGra impl... | Reproduce the AirRep LDS evaluation on FLAN: (1) Install airrep package: pip install git+https://github.com/sunnweiwei/AirRep or import from local copy; (2) Run evaluation: python scripts/04_evaluate.py --model_path sunweiwei/AirRep-Flan-Small --dataset sunweiwei/airrep-test --benchmark flan; (3) Verify LDS Spearman co... | {
"hours": 0.01,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "A100 80GB",
"wallclock_hours": 0.02,
"h100_equivalent_multiplier": 0.32,
"basis": "MRE uses pre-trained AirRep-Flan-Small weights (no training). Evaluation script 04_evaluate.py encodes 100K train + 6.5K test examples with ... | verified | available | natural | 0.01 | derived_from_config: MRE uses pre-trained AirRep-Flan-Small weights (no training). Evaluation script 04_evaluate.py encodes 100K train + 6.5K test examples with batch_size=128. Per README: GTE-Small inference takes 0.40s per 1000 examples. Total encoding: 106.5K examples / 1000 * 0.40s = ~43s. Similarity computation (t... | 0-8 | 0.0064 | true | true | 0 | Easy | 0.0064 | true | 0-8 | dev | {
"config": "AirRep-Flan-Small model, FLAN benchmark, softmax attention aggregation, full training/test sets",
"metric": "LDS (Linear Datamodeling Score, Spearman rank correlation)",
"value": "21.11",
"scope": "FLAN test set (6,520 examples across 66 NLP tasks)",
"match_bar_kind": "point_estimate"
} |
2511.07099 | E2E-VGuard effectively protects individual voice information by disrupting both timbre (speaker similarity) and pronunciation (WER increase) in production LLM-based end-to-end speech synthesis. | Abstract: 'we propose E2E-VGuard, a proactive defense framework... protects our voice from timbre and pronunciation perspectives to disrupt the text-pronunciation alignment of the pre-trained TTS models.' Table 1 reports that on VITS model, E2E-VGuard (UT) achieves SIM=0.113 and WER=96.735% versus clean (SIM=0.685, WER... | empirical | Run protect.py on a single LibriTTS audio file with default settings (500 epochs, epsilon=8, wav2vec2-base ASR), then fine-tune GPT-SoVITS on the protected audio and measure SIM and WER. | {
"paper_or_project": [
"https://arxiv.org/abs/2511.07099",
"https://wxzyd123.github.io/e2e-vguard/"
],
"code": [
"https://github.com/wxzyd123/E2E-VGuard"
],
"dataset": [
"https://github.com/wxzyd123/E2E-VGuard/tree/main/data/examples"
],
"weights": [
"https://huggingface.co/lj1995/GPT... | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "GitHub repo wxzyd123/E2E-VGuard verified via github_repo and github_file_contents. Contains complete implementation: E2E_VGuard.py (main algorithm class with 6 encoders, psychoacoustic masking, PGD optimization in start_pro... | Reproduce E2E-VGuard protection on a single LibriTTS audio sample: (1) Clone the repo and install dependencies from requirements.txt, (2) Manually download VITS pretrained_ljs.pth from the Google Drive link and GPT-SoVITS/WavLM/CosyVoice/StyleTTS2 via download_models.py, (3) Run `python protect.py --input_wav data/exam... | {
"hours": 0.03,
"basis_kind": "paper_reported",
"gpu_count": 1,
"gpu_type": "NVIDIA 4090",
"wallclock_hours": 0.027,
"h100_equivalent_multiplier": 0.32,
"basis": "Paper reports 97.982 seconds average for untargeted protection on LibriTTS using single NVIDIA 4090 GPU (Section 4.5 Time Overhead and Acceler... | verified | available | natural | 0.03 | paper_reported: Paper reports 97.982 seconds average for untargeted protection on LibriTTS using single NVIDIA 4090 GPU (Section 4.5 Time Overhead and Acceleration Strategies). Converting to H100-hours: (97.982 / 3600) * 0.32 = 0.0087 H100-hours per audio sample. For MRE evaluation across 3-5 samples with different ASR... | 0-8 | 0.00864 | true | true | 0 | Easy | 0.00864 | true | 0-8 | dev | {
"config": "E2E-VGuard (UT) on VITS model, LibriTTS dataset",
"metric": "Speaker similarity score (SIM)",
"value": "0.113",
"scope": "VITS fine-tuning on LibriTTS audio",
"match_bar_kind": "point_estimate"
} |
2502.08101 | SwapGT, which introduces a novel token swapping operation to generate diverse token sequences, achieves state-of-the-art node classification accuracy on standard graph benchmarks, outperforming both GNNs and existing Graph Transformers. | Abstract: 'we propose a new method termed SwapGT. SwapGT first introduces a novel token swapping operation based on the characteristics of token sequences that fully leverages the semantic relevance of nodes to generate more informative token sequences.' Table 1 (dense splitting): SwapGT achieves 94.98% (±0.41) on ACM,... | empirical | SwapGT on ACM dataset with dense splitting (50%/25%/25% train/val/test), 1 Transformer layer, hidden_dim=512, 8 attention heads, dropout=0.1, sample_num=6, num_aug=4, pp_k=3, lambda1=15, lambda2=0.5, peak_lr=0.001, using the token swapping operation with depth=2 for token sequence augmentation. | {
"paper_or_project": [
"https://arxiv.org/abs/2502.08101"
],
"code": [],
"dataset": [
"https://pytorch-geometric.readthedocs.io/en/latest/modules/datasets.html"
],
"weights": []
} | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "The NeurIPS proceedings page and OpenReview page state that code is available at https://github.com/JHL-HUST/SwapGT. The public GitHub repository was opened and contains runnable MRE-relevant Python and shell files, includi... | Clone the SwapGT repository (https://github.com/JHL-HUST/SwapGT), download datasets from the provided Google Drive link into ./dataset/de/ and ./pre_cal/de/ folders, then run: python train_test_sh.py --dataset acm --dropout 0.1 --attention_dropout 0.1 --hidden 512 --depth 2 --n_heads 8 --n_layers 1 --peak_lr 0.001 --pp... | {
"hours": 1,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "2080Ti",
"wallclock_hours": 5,
"h100_equivalent_multiplier": 0.2,
"basis": "Paper mentions 2080TI GPU but no explicit wall-clock time. MRE uses smallest dataset ACM (3,025 nodes, 13K edges). Model has 2 Transformer layers, hid... | verified | available | natural | 1 | derived_from_config: Paper mentions 2080TI GPU but no explicit wall-clock time. MRE uses smallest dataset ACM (3,025 nodes, 13K edges). Model has 2 Transformer layers, hidden_dim=256, k=4 tokens. Estimated ~5 min per training run, running 10 seeds = ~50 min total on 2080Ti. 2080Ti approximates 0.2x A100 which is 0.2x H... | 0-8 | 1 | false | false | 1 | Medium | 1 | false | 0-8 | dev | {
"config": "SwapGT, 1 Transformer layer, hidden=512, n_heads=8, sample_num=6, num_aug=4, depth=2, pp_k=3, dropout=0.1, peak_lr=0.001, lambda1=15, lambda2=0.5, dense splitting (50/25/25), ACM dataset",
"metric": "Mean accuracy (%)",
"value": "94.98%",
"scope": "ACM dataset with dense splitting",
"match_bar_ki... |
2502.06067 | The paper's Lipschitz-driven method achieves nominal 95% coverage for confidence intervals in spatial association estimation, while competing methods (OLS, Sandwich, KDEIW, GLS, GP BCIs) fail to achieve this coverage. | Abstract states 'Our approach is the first to guarantee nominal coverage in this setting and outperforms existing techniques in both real and simulated experiments.' Figure 1 (combined_plot_simulation) shows the proposed method and GP BCIs consistently achieve nominal coverage while other methods fail. | empirical | Single covariate simulation: N=300 source points, M=100 target points, shift=0.8, Lipschitz constant L=2*sqrt(2) approx 2.828, 250 seeds, evaluating 95% confidence interval coverage for the target-conditional OLS parameter. Run with: python two_dim_shift.py --num_seeds=250 --n=300 --m=100 --noise_std=0.1 --num_neighbor... | {
"paper_or_project": [
"https://arxiv.org/abs/2502.06067"
],
"code": [],
"dataset": [],
"weights": []
} | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "Live web search found and opened the public GitHub repository https://github.com/DavidRBurt/Lipschitz-Driven-Inference. The README identifies it as the reference implementation for the paper, gives installation instructions... | Reproduce the paper's main empirical result by running the single covariate simulation experiment. Steps: 1) Clone https://github.com/DavidRBurt/Lipschitz-Driven-Inference, 2) Install dependencies with 'pip install .' from root directory (dependencies listed in setup.py: numpy, scipy, matplotlib, scikit-learn, cvxpy, P... | {
"hours": 2,
"basis_kind": "compute_unspecified",
"gpu_count": null,
"gpu_type": null,
"wallclock_hours": null,
"h100_equivalent_multiplier": null,
"basis": "Paper reports CPU compute only (Intel Xeon W-2295, 36 threads): single covariate experiment took 9-10 minutes, full simulation suite under 2 hours.... | verified | available | natural | 2 | compute_unspecified: Paper reports CPU compute only (Intel Xeon W-2295, 36 threads): single covariate experiment took 9-10 minutes, full simulation suite under 2 hours. No GPU type or count specified. Order-of-magnitude estimate: 2 H100-hours is conservative upper bound for reproducing single covariate experiment if ru... | 0-8 | null | null | true | 1 | Medium | 2 | false | 0-8 | dev | {
"config": "TwoDimensionalShiftExperiment with N=300, M=100, shift=0.8, L=2*sqrt(2) approx 2.828, 250 seeds, 1-nearest neighbor, including intercept",
"metric": "95% CI coverage rate",
"value": "1.0 (100%)",
"scope": "250 random seeds, single covariate simulation with shift ranging from -0.8 to 0.8",
"match_... |
2505.19458 | Normalization layers in self-attention suppress the Jacobian's spectral norm and drive Lyapunov exponents toward zero (criticality), indicating high inference performance. ItrSA with normalization exhibits test-time scaling where accuracy improves as the number of loop iterations increases. | Abstract: 'the Lyapunov exponents computed from the Jacobians demonstrate that the normalized dynamics lie close to a critical state, and this criticality serves as a strong indicator of high inference performance.' Figure 5: ItrSA consistently improves accuracy as number of loops T increases. Figure 2: normalization d... | empirical | Train ItrSA model on SATNet Sudoku dataset (D=512, H=8, T=16, lr=0.0005, 100 epochs) and evaluate accuracy on RRN OOD dataset at varying loop counts T_eval to demonstrate test-time scaling. Compare OOD accuracy at T=16 vs T=32 to verify the model improves with more iterations. | {
"paper_or_project": [
"https://arxiv.org/abs/2505.19458"
],
"code": [
"https://github.com/autonomousvision/akorn (reference implementation with ItrSA training code for Sudoku)"
],
"dataset": [
"https://github.com/autonomousvision/akorn (SATNet download via data/download_satnet.sh, RRN download v... | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "OpenReview supplement evidence contains only neurips2025Recurrent_supp/neurips2025Recurrent_supp.pdf and a macOS metadata file, so it does not provide runnable code. Live web search did not find a first-party repository for... | Reproduce the ItrSA test-time scaling experiment on Sudoku: 1) Clone https://github.com/autonomousvision/akorn, 2) Download SATNet Sudoku dataset via cd data && bash download_satnet.sh, 3) Train ItrSA model: python train_sudoku.py --exp_name=sudoku_itrsa --epochs=100 --model=itrsa --lr=0.0005 --T=16, 4) Evaluate at T=1... | {
"hours": 2.5,
"basis_kind": "derived_from_config",
"gpu_count": 8,
"gpu_type": "H200 SXM",
"wallclock_hours": 0.34,
"h100_equivalent_multiplier": 0.92,
"basis": "Derived from model/dataset config: D=512, H=8, batch_size=100. SATNet dataset has ~10k training samples, so 100 epochs = 10k/100 = 100 steps p... | verified | available | natural | 2.5 | derived_from_config: Derived from model/dataset config: D=512, H=8, batch_size=100. SATNet dataset has ~10k training samples, so 100 epochs = 10k/100 = 100 steps per epoch. With batch processing overhead and GPU throughput on H200 (~40-50 steps/sec for this model size), 100 steps ≈ 2.5 sec per epoch. For 100 epochs: 25... | 0-8 | 2.5024 | false | false | 1 | Medium | 2.5 | false | 0-8 | dev | {
"config": "ItrSA model, D=512, H=8, trained at T=16, evaluated at T=32 on OOD (RRN) Sudoku dataset",
"metric": "Sudoku board accuracy on RRN out-of-distribution test set (%)",
"value": "34.4%",
"scope": "RRN Sudoku OOD test set",
"match_bar_kind": "point_estimate"
} |
2505.13431 | Practical approaches for incorporating symmetry into diffusion policies (relative trajectory actions with eye-in-hand perception, equivariant vision encoders, and Frame Averaging) achieve comparable or better performance than fully equivariant architectures while requiring significantly less implementation complexity. | Abstract states 'our method achieves performance on par with or exceeding fully equivariant architectures while greatly simplifying implementation.' Table 1 shows Rel Traj outperforms Abs Traj in 10/12 tasks (e.g., Stack D1: 98.0% vs 94.0%). Table 2 shows Pretrain + FA achieves 61.4% mean, competitive with EquiDiff (Vo... | empirical | Train Diffusion Policy with relative trajectory action representation on Stack D1 task from MimicGen benchmark (100 demos, Large FOV In-Hand observation, ResNet-18 CNN encoder, 600 epochs) and evaluate success rate. | {
"paper_or_project": [
"https://sym-in-dp.github.io"
],
"code": [
"https://github.com/pointW/sym_in_dp"
],
"dataset": [
"https://huggingface.co/datasets/amandlek/mimicgen_datasets"
],
"weights": []
} | {
"code_available": {
"value": true,
"verification": "tool_verified",
"evidence": "GitHub repo pointW/sym_in_dp verified with full tree structure. Contains: train.py entry point, complete config directory with all YAML configs (train_diffusion_unet_rel_traj.yaml, equi_enc, pretrained variants), full model... | Reproduce the paper's core claim by training a Diffusion Policy with relative trajectory action representation on the Stack D1 task from MimicGen. Steps: (1) Install dependencies from sym_in_dp README, (2) Download stack_d1 dataset from HuggingFace (amandlek/mimicgen_datasets), (3) Generate Large FOV observation with d... | {
"hours": 12,
"basis_kind": "paper_reported",
"gpu_count": 1,
"gpu_type": null,
"wallclock_hours": 3,
"h100_equivalent_multiplier": null,
"basis": "Paper appendix states training on 'internal clusters and desktops with different GPU models' and stack_d1 training takes from 3 hours (Stack D1) to 24 hours ... | verified | available | natural | 12 | paper_reported: Paper appendix states training on 'internal clusters and desktops with different GPU models' and stack_d1 training takes from 3 hours (Stack D1) to 24 hours (Pick Place D0) for Pretrain+FA variant. Total project compute ~3000 GPU hours across 12 tasks implies ~250 hours/task average, but stack_d1 is the... | 8-32 | null | null | true | 1 | Medium | 12 | false | 8-32 | dev | {
"config": "Diffusion Policy with Relative Trajectory + Large FOV In-Hand + CNN Encoder, trained on Stack D1 with 100 demos",
"metric": "Success rate (%)",
"value": "98.0%",
"scope": "Stack D1 task in MimicGen benchmark",
"match_bar_kind": "point_estimate"
} |
2512.03528 | CC-MADDPG achieves superior performance over baselines (FC-MADDPG, Dropout-MADDPG, MADDPG, MAIC) under various communication constraints in multi-agent particle environments. | Abstract: 'we validate the effectiveness of our approach across several communication-constrained benchmarks.' Table 1: CC-MADDPG achieves 134.7 mean episode reward in Simple_Tag (3 agents) unrestricted vs 75.9 for FC-MADDPG; under heavy DBC, CC-MADDPG maintains 138.0 while FC-MADDPG drops to 1.5. | empirical | Train CC-MADDPG on Simple_Tag (3 agents) with dropout-0.2 communication prior, 4M timesteps total, evaluate under Heavy DBC (distance threshold=1) constraint using average episode cumulative reward. | {
"paper_or_project": [
"https://arxiv.org/abs/2512.03528"
],
"code": [],
"dataset": [
"https://github.com/openai/multiagent-particle-envs",
"https://github.com/Farama-Foundation/PettingZoo"
],
"weights": []
} | {
"code_available": {
"value": false,
"verification": "tool_searched_not_found",
"evidence": "No first-party implementation for CC-MADDPG was found after searching the exact title, arXiv ID 2512.03528, method names/acronyms including CC-MADDPG and Du-MIE, author/title variants, and GitHub/Hugging Face sco... | Reproduce CC-MADDPG algorithm and run it on Simple_Tag with 3 agents under Heavy DBC constraint (distance threshold=1). Implement the communication-constrained prior modeling (binary communication link parameter), the Du-MIE module (JSD for maximizing MI with lossless messages, CLUB for minimizing MI with lossy message... | {
"hours": 1,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "RTX A5000 24GB",
"wallclock_hours": 6,
"h100_equivalent_multiplier": 0.18,
"basis": "Derived from paper's implementation details (Appendix): 1 GPU (RTX A5000 24GB), 4M total training steps, update every 100 steps after 1024 wa... | verified | available | natural | 1 | derived_from_config: Derived from paper's implementation details (Appendix): 1 GPU (RTX A5000 24GB), 4M total training steps, update every 100 steps after 1024 warmup = ~39,000 updates. Each update processes batch 1024 through 6 small NNs (actors 3x(64,64), critic (64,64), JSD 32, CLUB 32). At ~0.55s/update on A5000, t... | 0-8 | 1.08 | false | false | 3 | Hard | 1 | false | 0-8 | dev | {
"config": "CC-MADDPG, 3 agents, dropout-0.2 prior, Heavy DBC (threshold=1)",
"metric": "average episode cumulative reward",
"value": "138.0±88.1",
"scope": "Simple_Tag MPE, 100 evaluation episodes",
"match_bar_kind": "point_estimate"
} |
2510.25739 | Hawk achieves a 1.71× speedup over standard autoregressive models for text-to-image generation while preserving image fidelity and diversity, by leveraging spatial context through dual-direction draft heads that speculate in both horizontal and vertical directions. | Abstract states 'Experimental results on multiple text-to-image benchmarks demonstrate a 1.71x speedup over standard AR models, while preserving both image fidelity and diversity.' Table 1 reports Hawk (Spatial Draft Heads) achieves 1.71× speedup on COCO2017 with FID 90.71 and CLIP 33.39. | empirical | Hawk spatial speculative decoding with dual-direction draft heads (horizontal + vertical) on Lumina-mGPT-7B-768 base model, trained on 6,000 LAION aesthetic images (8-12 hours on single RTX 3090), evaluated on COCO2017 validation set (500 images), 768×768 images, top-k=2000, temperature=1.0, classifier-free guidance sc... | {
"paper_or_project": [
"https://arxiv.org/abs/2510.25739"
],
"code": [],
"dataset": [
"https://cocodataset.org/"
],
"weights": []
} | {
"code_available": {
"value": false,
"verification": "tool_searched_not_found",
"evidence": "Searched exact title, arXiv ID, method name, 'Spatial Speculative Decoding', GitHub-scoped, and Hugging Face-scoped queries. I found the arXiv/OpenReview paper and the upstream Lumina-mGPT repository, whose READM... | Reproduce the Hawk spatial speculative decoding method: (1) Implement dual-direction draft heads with horizontal and vertical speculation on top of Lumina-mGPT-7B-768, (2) Train the spatial draft heads on 6,000 LAION aesthetic images using AdamW optimizer with lr=2e-5, weight_decay=0.1, beta=(0.9, 0.95), lambda_k=1, (3... | {
"hours": 1.8,
"basis_kind": "paper_reported",
"gpu_count": 1,
"gpu_type": "RTX 3090",
"wallclock_hours": 10,
"h100_equivalent_multiplier": 0.18,
"basis": "Paper reports draft head training takes 8-12 hours on a single RTX 3090 GPU using 6000 LAION aesthetic images. RTX 3090 is not in the standard GPU ta... | verified | available | natural | 1.8 | paper_reported: Paper reports draft head training takes 8-12 hours on a single RTX 3090 GPU using 6000 LAION aesthetic images. RTX 3090 is not in the standard GPU table; estimated ~0.57× A100 80GB, so multiplier = 0.57 × 0.32 = 0.18. H100-hours = 1 × 10 × 0.18 = 1.8. This covers fine-tuning only; inference/evaluation t... | 0-8 | 1.8 | false | false | 3 | Hard | 1.8 | false | 0-8 | dev | {
"config": "Hawk with Spatial Draft Heads (vertical + horizontal draft heads) on Lumina-mGPT-7B-768, evaluated on COCO2017 validation set (500 images), 768×768 resolution, top-k=2000, temperature=1.0, guidance scale=3.0",
"metric": "Inference acceleration speedup",
"value": "1.71×",
"scope": "COCO2017 validati... |
2505.17282 | After a single gradient step on logistic loss, token embeddings capture importance by aligning with the output vector proportionally to token frequency, and gradient flow on the CLS embedding converges to a max-margin direction that selects important tokens for classification. | Abstract states embeddings capture token importance by aligning with output vector v proportionally to frequency. Figure 1 (synthetic data) and Figures 3-4 (IMDB/Yelp) empirically validate token importance correlation via dot-product scatter plots showing positive/negative token separation. | empirical | One-layer softmax attention model on synthetic K-level data with |S|=2048 tokens, K=8 importance levels, T=256 sequence length, embedding dimension 2048, trained with AdamW (LR=1e-4, weight decay=1e-4) for 196 epochs until convergence. | {
"paper_or_project": [
"https://arxiv.org/abs/2505.17282",
"https://openreview.net/forum?id=0dd14d46088a565f42eb312564a37b69e8d3086e"
],
"code": [],
"dataset": [
"https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews",
"https://www.kaggle.com/datasets/yelp-dataset/ye... | {
"code_available": {
"value": false,
"verification": "tool_searched_not_found",
"evidence": "Searched exact title, arXiv ID 2505.17282, OpenReview ID y5IUGnpDJ8, author/title variants, and GitHub/code variants. Papers With Code page for this paper explicitly showed 'No code implementations yet.' The Open... | Implement the one-layer softmax attention model for binary text classification as defined in paper Equation 1: f(X; p, E) = Softmax(p^T E_X^T) E_X v, where E_X contains token embeddings, p is CLS embedding, v is output vector. Generate synthetic data according to K-level model in Section 5 (Equations 6-8) with K=8, |S|... | {
"hours": 2,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "A100 80GB",
"wallclock_hours": 6,
"h100_equivalent_multiplier": 0.32,
"basis": "Model has ~50M parameters (embedding 2048x2048 + output vector 2048 + cls embedding 2048). Dataset is small: ~400K tokens total across training (n... | verified | available | natural | 2 | derived_from_config: Model has ~50M parameters (embedding 2048x2048 + output vector 2048 + cls embedding 2048). Dataset is small: ~400K tokens total across training (n sequences, T=256, with batch 128, 196 epochs). Training converges quickly on a single A100. Paper reports no GPU-hours; estimate derived from model+data... | 0-8 | 1.92 | false | false | 3 | Hard | 2 | false | 0-8 | dev | {
"config": "One-layer attention model on synthetic K-level data, d=2048, T=256, all parameters trained until convergence",
"metric": "Correlation coefficient between token embedding dot-products with v and token importance alpha_s",
"value": "Clear separation: positive tokens have positive dot-product with v pro... |
2511.10107 | RobIA achieves superior continual test-time adaptation performance for stereo depth estimation across dynamic target domains while maintaining computational efficiency | Abstract states 'RobIA achieves superior adaptation performance across dynamic target domains while maintaining computational efficiency.' Table 1 shows RobIA (AttEx-MoE + AT) achieving D1-all 2.77% and EPE 0.91 on DrivingStereo CTTA benchmark, outperforming no-adaptation baseline (D1-all 5.56%) and other PEFT methods. | empirical | CoEx backbone with AttEx-MoE module + AdaptBN Teacher for CTTA on DrivingStereo dataset (500 frames per domain from dusky, cloudy, rainy sequences, 10 rounds) | {
"paper_or_project": [
"https://github.com/0ju-un/RobIA",
"https://arxiv.org/abs/2511.10107"
],
"code": [],
"dataset": [
"https://dsec.ifi.uzh.ch/"
],
"weights": []
} | {
"code_available": {
"value": false,
"verification": "tool_verified",
"evidence": "The first-party GitHub repository at https://github.com/0ju-un/RobIA is public but contains only assets and README.md; the README explicitly says 'Code will be released soon,' and GitHub shows no releases. Searches for the... | Clone the RobIA repository when code is released, set up the CoEx stereo matching environment, download the DrivingStereo dataset, initialize the AttEx-MoE module with AdaptBN Teacher, run 10 rounds of CTTA adaptation on the DrivingStereo sequences (dusky, cloudy, rainy), and evaluate D1-all error rate to verify it fal... | {
"hours": 2,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "A100 80GB",
"wallclock_hours": 6,
"h100_equivalent_multiplier": 0.32,
"basis": "MRE uses single GPU inference/adaptation on a subset of frames. Paper Table 5 (Computational Cost) reports AttEx-MoE runtime of 97.34ms per frame ... | verified | available | natural | 2 | derived_from_config: MRE uses single GPU inference/adaptation on a subset of frames. Paper Table 5 (Computational Cost) reports AttEx-MoE runtime of 97.34ms per frame on RTX 3090 for inference + adaptation. For minimal CTTA evaluation on DrivingStereo: 500 frames x 3 conditions = 1500 frames per round x 10 rounds = 150... | 0-8 | 1.92 | false | false | 3 | Hard | 2 | false | 0-8 | dev | {
"config": "CoEx + AttEx-MoE + AT on DrivingStereo, CTTA setting, 10 rounds",
"metric": "D1-all error rate (%)",
"value": "2.77",
"scope": "DrivingStereo CTTA benchmark, Mean across all rounds",
"match_bar_kind": "direction"
} |
2506.09518 | HAIF-GS achieves state-of-the-art dynamic scene reconstruction by combining sparse anchor-driven deformation with self-supervised induced flow guidance and hierarchical anchor propagation. | Abstract states 'HAIF-GS significantly outperforms prior dynamic 3DGS methods in rendering quality, temporal coherence, and reconstruction efficiency.' Table 2 (D-NeRF Mean) shows PSNR 42.00/SSIM 0.997/LPIPS 0.010; Table 1 (NeRF-DS Mean) shows PSNR 24.63/MS-SSIM 0.9014/LPIPS 0.1342. | empirical | Single D-NeRF scene (Hook) training with HAIF-GS for ~30,000 iterations on single RTX 3090 GPU, evaluating PSNR, SSIM, LPIPS metrics. | {
"paper_or_project": [
"https://arxiv.org/abs/2506.09518"
],
"code": [],
"dataset": [
"https://github.com/albertpumarola/D-NeRF"
],
"weights": []
} | {
"code_available": {
"value": false,
"verification": "tool_searched_not_found",
"evidence": "No first-party HAIF-GS implementation was found after searching the exact title, arXiv ID 2506.09518, acronym variants HAIF-GS/HAIF GS/haifgs, GitHub-scoped queries, Hugging Face-scoped queries, and artifact term... | Clone the HAIF-GS GitHub repository (github.com/EchoPickle/HAIF-GS), install required dependencies (PyTorch, Gaussian Splatting libraries as specified in the paper), download the D-NeRF dataset from github.com/albertpumarola/D-NeRF, and train HAIF-GS on the Hook scene for 30k iterations. Evaluate PSNR on the test set a... | {
"hours": 2.56,
"basis_kind": "derived_from_config",
"gpu_count": 1,
"gpu_type": "RTX 3090",
"wallclock_hours": 8,
"h100_equivalent_multiplier": 0.32,
"basis": "Single-scene training on D-NeRF at 800x800 resolution. Paper states experiments use 'single NVIDIA RTX 3090 GPU'. Estimated ~8 hours per scene f... | verified | available | natural | 2.56 | derived_from_config: Single-scene training on D-NeRF at 800x800 resolution. Paper states experiments use 'single NVIDIA RTX 3090 GPU'. Estimated ~8 hours per scene for ~10k iterations based on comparable dynamic 3DGS methods. RTX 3090 equivalent to A100 80GB is 0.32x H100 rate. Conversion: 1 GPU * 8 hours * 0.32 = 2.56... | 0-8 | 2.56 | false | false | 3 | Hard | 2.56 | false | 0-8 | dev | {
"config": "D-NeRF Hook scene, HAIF-GS default config, 800x800 resolution",
"metric": "PSNR (dB)",
"value": "39.38",
"scope": "D-NeRF Hook scene",
"match_bar_kind": "point_estimate"
} |
RECLAIM
RECLAIM is a benchmark of 100 NeurIPS 2025 papers for measuring whether an AI agent can reproduce a published machine learning result. For each paper the benchmark fixes, before any agent starts, the central claim, the single result a run has to recover, what counts as a successful reproduction, the artifacts the authors released, a difficulty tier, and an audited GPU-hour estimate.
This repository holds the benchmark rows. The agent harness, the grading rubric, the batch scripts, and the run transcripts live with the code.
- Code: github.com/mithils3/reclaim
- Run logs: reclaim-traces.vercel.app
Splits
| Split | File | Papers | In-row marker | Purpose |
|---|---|---|---|---|
test |
eval_100.jsonl |
100 | split="eval" |
The frozen evaluation benchmark |
validation |
dev_split.jsonl |
14 | split="dev" |
Development set, disjoint from test |
There is no train split. No arXiv ID appears in both splits.
from datasets import load_dataset
eval_100 = load_dataset("Mithilss/reclaim", split="test") # 100 papers
dev_14 = load_dataset("Mithilss/reclaim", split="validation") # 14 papers
Tiers
The tier is derived from what the authors released, so it measures the work an agent has to
do rather than the difficulty of the science. The tier field carries the stored values
Easy, Medium and Hard, which the paper reports as Run, Retrain and Reimplement.
tier |
Paper name | The release | What the agent must do | Eval | Dev |
|---|---|---|---|---|---|
Easy |
Run | Code, data and weights | Run the released artifacts | 34 | 5 |
Medium |
Retrain | No weights | Train the model first | 33 | 4 |
Hard |
Reimplement | No code either | Write the implementation | 33 | 5 |
Compute bands over the evaluation split, binned by the audited H100-hour estimate:
| Tier | 0-8 | 8-32 | 32-96 | Audited H100-h |
|---|---|---|---|---|
| Run | 27 | 7 | 0 | 142.71 |
| Retrain | 16 | 13 | 4 | 380.91 |
| Reimplement | 16 | 9 | 8 | 630.18 |
| All | 59 | 29 | 12 | 1,153.8 |
A 96 H100-hour cap was applied to the evaluation split after the human audit, so no evaluation paper exceeds it. The development split totals 26.89 audited H100-hours.
splits_summary.json records the selection counts, the per-tier band quotas and the
development IDs.
Row schema
Every row holds 25 top-level fields and four nested objects, all fixed before any agent starts. Rows carry metadata and links only, with no paper text.
| Field | Type | Description |
|---|---|---|
custom_id |
string | arXiv ID, the primary key |
central_claim |
string | The paper's central empirical claim in one sentence |
claim_evidence |
string | Quoted paper text grounding the claim |
mre_config |
string | Prose recipe for the cheapest configuration that tests the claim |
agent_task |
string | Reproduction instruction written during construction |
verified_links |
object | Tool-confirmed artifact URLs |
signals |
object | Per-artifact availability audit |
match_target |
object | The quantity a run must match |
h100_estimate |
object | Compute estimate and its basis |
score |
int | Artifact-availability score from the four signals, 0 to 3 |
tier |
string | Easy, Medium or Hard, derived from score |
split |
string | eval or dev |
selection_band |
string | Compute band used for stratified selection |
h100_band |
string | Compute band, one of 0-8, 8-32, 32-96 |
h100_hours_estimate |
float | Estimated H100-hours to run the match target |
h100_estimate_basis |
string | Free-text justification for the estimate |
audited_h100_hours |
float | The estimate after the arithmetic audit |
h100_recomputed_hours |
float or null | Recomputed hours when the estimate was revised |
h100_arithmetic_mismatch |
bool or null | Set when estimate arithmetic disagreed |
h100_hours_adjudicated |
bool | Whether the recompute replaced the stated estimate |
h100_needs_human_review |
bool | Whether the estimate was flagged for review |
paper_kind |
string | Paper type. All rows are empirical |
verification_status |
string | Classifier verification state. All rows are verified |
web_verification |
string | Web-retrieval state. All rows are available |
exit_reason |
string | Classifier exit reason. All rows are natural |
Nested objects:
verified_links:paper_or_project,code,dataset,weights, each a list of URLs confirmed by a tool, empty when none was located.signals: one object per signal (code_available,dataset_available,weights_available,dataset_is_standard), each withvalue,verification(tool_verified,tool_searched_not_foundornot_applicable) andevidence.match_target:config,metric,value,scopeandmatch_bar_kind(point_estimate,direction,threshold,magnitudeorrange).h100_estimate:hours,basis_kind,gpu_count,gpu_type,wallclock_hours,h100_equivalent_multiplierandbasis.
For 62 of the 100 evaluation papers the match bar is a point estimate, for 21 a stated baseline the run must beat, for 14 a reported threshold it must clear, for 1 the size of a reported delta, and for 1 a reported range it must fall inside. One row has no bar kind set. A run matches a point estimate when its measured value lies within the authors' stated tolerance, or within 5% relative when the paper states none.
Construction
The corpus starts from the NeurIPS 2025 index of the ai-conferences collection, matched
to arXiv IDs, with each paper's arXiv source package and OpenReview supplement fetched into
one bundle. A language model classified a 1,000-paper sample through an agent loop over ten
tools across GitHub, Hugging Face, URL fetches and the supplement, and every artifact signal
records the tool observation that established it. Score and tier are then computed by code
from the four signal booleans. A 200-row pool, split across tiers and compute bands, went
through a human audit, and the benchmark was selected from the audited pool. The paper
documents each stage.
Intended use
Use the rows as the fixed input to a reproduction agent, one run per paper, and grade the
run against match_target. Grading a run on the agent's own report inflates the result,
so the paper grades from execution evidence with a separate model.
The rows are not a training set. Publishing fine-tunes on them would make later numbers on this benchmark hard to interpret.
Licensing
The rows are released under CC BY 4.0. They contain claim statements, quoted evidence sentences and links to third-party artifacts, each of which stays under its own license.
Citation
@misc{salunkhe2026reclaim,
title = {RECLAIM: Can Agents Reproduce the Claims of Machine Learning Papers?},
author = {Salunkhe, Mithil and Ding, Haochen and Verma, Samridhi and Kindratenko, Volodymyr},
year = {2026},
note = {Preprint}
}
Contact: mithils3@illinois.edu
- Downloads last month
- 117