Datasets:

HughieHu
/

drpixel-bench

qid stringlengths 9 9	question stringlengths 90 387	gold_answer stringlengths 19 429	modality stringclasses 4 values	doc stringlengths 2 36	arxiv stringlengths 2 36	page int64 0 31
qc5512113	A Chinese developed video language model would seem to have a home field edge on Chinese cultural content. Does Qwen2.5-VL-72B actually score higher on Chinese culture video questions than on Western or European ones?	No. Even the strongest open, Chinese developed model, Qwen2.5-VL-72B, does better on Western and European culture questions and worse on Chinese centric ones, reaching only about 65.8 percent on Chinese cultural understanding, with Chinese history questions especially weak. The benchmark reports that all models perform...	text	2504.17821	2504.17821	1
qe7823c03	Does providing interactive environment feedback consistently improve task success across different large language models compared to tool-use alone, or can it actually degrade performance for certain models?	No, gpt-4-0613 experiences a performance drop of -0.7 points.	table	09d48a2a-4ad0-5a7f-84ec-557ac57f5830	09d48a2a-4ad0-5a7f-84ec-557ac57f5830	7
qe64cc8c7	Translating messy natural language safety policies into first order logic sounds like something big proprietary models would nail better than open source ones. Do proprietary developers' policies actually compile to first order logic more accurately than open source players like Mistral and Meta?	No. In policy to logic binary accuracy, averaging 92.06 percent, open source developers Mistral and Meta both hit a perfect 100.00 percent, matching or beating proprietary sources like OpenAI at 92.31, Anthropic at 88.24, DeepSeek at 98.08, and Baidu at 85.71. Several proprietary policies score below 100, so proprietar...	table	2605.24883	2605.24883	7
q0520b0df	Adaptive rendering loss regularization is supposed to consistently outperform frequency-based regularization in sparse-view NeRFs, does that actually hold across all sparse-view settings, or does the simpler frequency method still win under certain view counts?	No, frequency regularization achieves a better average score under the 6-view setting	table	2410.17839	2410.17839	9
qa3ad63b2	I took a base open-source LLM and continued training it on my domain's corpus. Should I expect it to beat the original on every task in that domain?	It can hurt on some, the domain-adapted model doesn't uniformly beat its base. It loses on several of the domain tasks (≈3 of 8, including a sharp drop on one, ~41 vs ~54), and the overall average barely moves (≈17.4 vs ≈16.7). Adaptation gives only a marginal average gain and regresses on parts.	table	doc_04a68acfeda2	2406.04614	5
qaae7d23d	Self-supervised consistency loss is supposed to eliminate artifacts without sacrificing detail, does this actually hold when reconstructing fine geometric features like sharp edges and corners?	No, it reconstructs sharp, flat chamfered corner edge details.	figure	2405.18131	2405.18131	13
qfed390d0	A cheap gradient-based token-attribution proxy is usually expected to lose to the expensive perturbation-based version. Are there any spots where the cheap gradient method actually comes out ahead?	Yes, in exactly two cells. The gradient-based method (OAR-G) beats the perturbation-based one (OAR-P) on Qwen2.5-7B / MATH500 P@1 (78.7 vs 78.4) and on Qwen2.5-Math-7B / GSM8K P@1 (92.9 vs 92.7). In every other model-metric combination OAR-P is equal or higher (AIME24 P@1 on Qwen2.5-Math-7B ties at 33.5).	table	2601.07408	2601.07408	4
q99ff13ab	Turning up the sampling temperature adds randomness, so it ought to weaken how strongly iterated LLM telephone-game chains settle on an attractor. Does that hold everywhere, or flip once the rewriting task is tightly constrained?	It reverses under tight constraints. For constrained rewriting tasks such as Rephrase and Take-inspiration, higher temperature increases attractor strength rather than decreasing it.	text	2407.04503	2407.04503	7
qc158ed90	Monitoring more neurons to detect a reasoning model's 'exit intent' should give a steadier signal and monotonically better accuracy. Does accuracy actually keep improving as you monitor more neurons?	No. Accuracy is non-monotonic: for Qwen3-8B it rises from ~87.5% (3 neurons) to a peak ~94.2% at 7 neurons then edges down (~94.0% at 9, ~93.8% at 10); DeepSeek-R1-Distill-7B similarly peaks ~93.2% around 7-9 neurons then dips to ~92% at 10.	figure	2602.02010	2602.02010	6
q569df1df	In federated learning, clients hold LoRA adapters with different ranks. The replication padding strategy is meant to combine mismatched ranks during aggregation. When building the transposed matrix for the lower rank client, does it just repeat that client's own adapter rows, or does it append transposed rows taken fro...	It appends transposed row vectors taken from the high rank client's matrix, rather than repeating the low rank client's own rows.	equation	2406.17477	2406.17477	2
qdf9937c3	In federated instruction tuning, balanced, identically distributed client data looks like the natural performance ceiling, with heterogeneity only hurting. Does performance actually move in step with the degree of non-IID-ness across clients?	No. This work finds there is no monotonic link between the degree of non-IID client distribution and LLM performance in federated domain specific instruction tuning. The real driver is how well the clients cover the domain together, not heterogeneity by itself.	text	2409.20135	2409.20135	0
q7e635c6a	If I use GPT-4 with self-correction to generate Verilog, can I count on its FPGA resource usage staying close to human-written designs, or can it sometimes produce wildly inefficient hardware?	You can't fully count on it — it's comparable or better on most designs, but on the RAM design it produces ~18× the reference's area (1464 vs 79 ALMs) and fails timing (negative slack).	table	doc_0b1648b2cc57	2406.00115	7
q90b546da	Pool Skip is a modification meant to help vision transformer style architectures. Does adding pool skip consistently lower the top-1 error?	No. It raises the top-1 error for every model tested. ViT increases by 0.22, CCT by 0.02, and CVT by 0.38.	table	2409.13154	2409.13154	6
q07e81c51	Training with a larger vocabulary is assumed to be the key to better open vocabulary 3D generalization as the number of categories grows. Does a bigger vocabulary actually win out over using query templates?	No. Using query templates that link attributes to object classes works better than just scaling vocabulary size.	text	2408.11030	2408.11030	5
qdbe93d65	For instruction tuning, I guess that the scientific data contributes a lot to the training result, but does mixing in general-domain instruction data actually keep pushing performance up on the scientific literature task?	Only at the larger 70B scale: the model trained on SciRIFF+TÜLU improves to 50.7 versus 48.8 for SciRIFF alone, while at 7B the two are tied at 47.0.	table	doc_a529f5083876	2406.07835	6
qedd62a38	Step-level reward feedback should only ever help. Is there a kind of task where adding a process reward model actually lowers accuracy?	Yes — visual-dominant tasks. There PRMs drop accuracy ~2% (vs a ~3% gain on text-heavy tasks), because unclear step segmentation and unnecessary reasoning make the PRM overweight irrelevant steps.	text	doc_de11afe65658	2503.20271	3
q0cae03bd	With certified training, does post training bound tightness get steadily worse as network depth increases, or does it behave differently?	It is non-monotonic. It decreases to a minimum at an intermediate depth, then increases again.	figure	0944f333-30ee-5652-bc0a-605d24293116	0944f333-30ee-5652-bc0a-605d24293116	6
qb8d86ebc	Iterative prompting strategies are supposed to keep scaling well as test-time compute grows. Do they actually beat standard chain-of-thought prompting once the compute budget gets large?	No. As sampling time and compute increase, complicated prompting strategies with strong initial performance lose their advantage over standard chain-of-thought prompting.	text	2505.10981	2505.10981	9
q6914a9c4	LoRA adapts every layer independently, which could let neighboring layers pull in inconsistent directions. Does this actually show up empirically, and how bad is it?	Yes. The paper measures low cosine similarity, around 0.27 to 0.41, between the update gradients of adjacent layers. This evidences structural incoherence, which motivates a training only GNN coordinator to align updates across depth.	equation	2603.14228	2603.14228	2
qb9a8548c	Does progressively training from the Easy stage to the Hard stage consistently improve the Human Preference Score (HPS)? The point of adding harder stages is to keep raising preference scores.	No. The easy stage actually gets the highest Human Preference Score. Later stages score lower on this metric.	table	2405.20216	2405.20216	5
q4fd525b4	Boosting a symbolic bag of words classifier with LLM generated features should close the gap with BERT on keyword driven topic classification, but still trail badly on sentiment that needs compositional or negation understanding. Am I right?	Yes. On keyword heavy R52, the LLM guided symbolic model reaches 94.45, edging out BERT's 94.26. But on compositional sentiment task SST2, BERT dominates at 94.00 versus 85.24, a roughly 9 point gap. The pattern repeats on AG News, where BERT scores 94.75 versus 93.10.	table	2604.12223	2604.12223	6
q4cb35519	Parameter efficient equivariant fine tuning is pitched as matching or beating full fine tuning. On out of distribution test cases specifically, do the PEFT variants still hold up, or does full fine tuning reclaim the lead?	On out of distribution evaluations, full fine tuning outperforms both PEFT methods, ELoRA and MMEA, even though MMEA leads on in distribution benchmarks. The parameter efficiency edge does not extend to OOD.	text	2511.06696	2511.06696	6
q7cd52c91	I think a simple, non-strategic partner would be easiest to peg, which fewer layers of intent to untangle, so an adaptive agent should lock onto it faster than onto a recursive strategic partner. Which partner type does the agent actually identify more quickly?	The more complex strategic (ToM-1) partner is identified faster: its correct expert weight P^(1) converges to ~1.0 within about 10-15 steps, whereas for the simple ToM-0 partner the correct weight P^(0) rises slowly (a delayed step) and only approaches 1.0 after ~25+ steps.	figure	2603.16264	2603.16264	5
qbb64ed43	Transition influences along different paths could cancel out and block latent identifiability. Is there a specific regime of transition dynamics that guarantees this cancellation will not happen?	Yes. It holds only under what the paper calls weakly diverse lossy transitions.	text	0142149a-5c51-5917-bf03-0a62c623ffc2	0142149a-5c51-5917-bf03-0a62c623ffc2	19
q0d75d59f	In a closed-book setting with no retrieval, does bolting trained virtual soft-prompt tokens onto a frozen LLM actually beat plain zero-shot prompting, or do the extra tokens just get in the way?	It beats it. In the no-retrieval columns, virtual-token tuning SPRING averages 16.32 EM vs 12.59 for zero-shot prompting. By contrast prefix-tuning collapses to 0.33 EM and LoRA to 0.02 EM without retrieval - the virtual-token method is the only tuning approach that helps closed-book.	table	2405.19670	2405.19670	4
q4f500064	A frontier multimodal model posts high accuracy on a medical-imaging QA benchmark, but does that hold up on the fine-grained clinical calls including naming the exact condition and where it is, or does it basically drop to chance there?	It collapses. Even top models GPT-4o, GPT-4V, Gemini Pro perform close to random guessing on the specialized categories, Condition/Finding and Position, despite high headline accuracy on general Med-VQA.	text	2405.20421	2405.20421	1
q1e1f7abf	Optimized serving engines like vLLM are usually assumed to be more energy efficient than standard Transformers across the board. Does this advantage actually hold during the prefill stage of LLM inference?	No. During the prefill stage, standard Transformers and DeepSpeed Inference use less energy than optimized engines like vLLM and TensorRT-LLM, which consume about three times more energy per token in that stage.	text	2512.03024	2512.03024	4
q737d9244	A specialized flow-based joint generator is expected to beat a VAE baseline on every modality-specific metric. In a multimodal RNA and ATAC generation task, does the joint flow model CFGen actually match or beat the VAE baseline MultiVI on the RNA MMD metric?	No, it loses. On RNA MMD, where lower is better, the joint model CFGen-multi scores 0.89 plus or minus 0.02, worse than the VAE baseline MultiVI at 0.86 plus or minus 0.03. The best RNA MMD score, 0.86, comes from MultiVI and from the RNA-only variant of CFGen, not from the multimodal CFGen.	table	2407.11734	2407.11734	7
q92daea30	As code completion granularity moves from API level to line level to function level, how does the performance gap between self-retrieval and external retrieval with a dense retriever change?	The gap first decreases and then increases again, going from about 0.030 at the API level to 0.015 at the line level and back up to 0.018 at the function level.	table	2507.19033	2507.19033	6
q046e70ac	As the number of sequential refinement iterations increases, what happens to task accuracy?	Accuracy is non-monotonic. It rises with more refinement rounds, peaks in the middle around rounds 5 to 6 at 80.4, and then declines.	figure	2507.15512	2507.15512	6
q023cfbe4	Capable LLMs with strong reasoning are supposed to spot logical gaps in evidence. When verifying groundedness on incomplete evidence, do they actually beat a random baseline?	No. They perform worse than random because they tend to classify incomplete evidence as entailment, filling the gaps with their own internal knowledge.	text	2509.16534	2509.16534	4
q877a033d	Effective human persuaders are known for balancing objective information sharing with expressing trust. Do LLMs match that same balance when they try to persuade?	No. LLMs show the opposite profile. They convey less knowledge and consistently express more trust than the human delta comments do.	text	2606.08076	2606.08076	6
qf85b14bb	What effect does making an LLM evaluator's scoring criterion more detailed have on the consistency of its judgments?	It's inconsistent. Adding criterion detail doesn't uniformly raise inter-rater agreement; the trend varies by setting and model (sometimes up, often flat or down), so more detail is not a reliable fix.	figure	doc_0456fb760f2a	2412.00543	2
q7dffbb66	Tree of Thought is supposed to beat Chain of Thought with self consistency on math reasoning. Does that still hold under a strict token budget?	No. Chain of Thought with self consistency still wins under a strict token budget on math reasoning tasks like GSM.	text	2404.11041	2404.11041	4
q337a7341	Cutting token gradient conflicts inside MoE experts ought to raise gradient consistency at every layer. Does that actually hold layer by layer, or does it help some depths and hurt others?	Not uniform. The method improves gradient consistency in deeper layers while decreasing it in shallower layers.	text	2406.19905	2406.19905	9
q07e96a41	When my coding agent whiffs on a bug, I assumed it usually just couldn't find the right file, but is the real bottleneck locating the code?	It's writing the fix, not locating — incorrect implementation accounts for ~40% of failures, while failing to find the right file is just ~2% (wrong edit location ~13%).	figure	doc_1d386f7e83cc	2405.15793	7
q5d472f79	Reasoning-focused models like o4-mini are supposed to hold up well against visual clutter. Does that still hold once line crossings are introduced into the diagram tracing task?	No. O4-mini is the only model that shows a statistically significant negative effect from crossings, with a log-odds of negative 0.3925.	table	2507.13361	2507.13361	10
qb73c7d20	For zero-day attack detection I want the fewest false alarms. Which model wins on false-positive rate, and does it have to give up overall accuracy/F1 to get there?	The proposed model has the best false-positive rate (0.2%, plus precision 99.99% and specificity 99.76%), but gives up the top F1 (98.74 vs Jung et al. 99.80) and accuracy (97.58 vs 99.88).	table	doc_039c2f5a8704	2504.14122	17
q3aa2133a	In in-context learning, if you block the test example from attending to the content semantic tokens in the demonstrations, does performance collapse, or do LLMs mostly ride on structure tokens anyway?	Performance barely drops. Ablating attention to content tokens has a negligible direct effect, because LLMs leverage content tokens only indirectly, aggregating their information into the representations of the performance-critical template and stopword tokens e.g. 'Answer. '.	text	2401.11323	2401.11323	0
q4891bf74	When training FSLR for multi-step reasoning, is the loss computed over the whole generated response or only the first planning step?	Only the first planning step. FSLR trains strictly on the initial planning tokens rather than the full response.	equation	2601.03682	2601.03682	2
q37d921af	Bolting an expensive tree search decoder onto a weak or a strong code LLM should always pay off. Does the ranking between an expensive search method and a cheap memory-based one actually flip when you swap the backbone?	Yes. On the CHESS-SDS set Alpha-SQL beats Memo-SQL on the strong backbone Qwen2.5-Coder-32B, 58.5 percent versus 57.6 percent execution accuracy, but loses on the weak backbone Llama-3.1-8B, 49.6 percent versus 52.1 percent. The ranking flips with the backbone.	table	2601.10011	2601.10011	6
qf6021642	VLM as judge systems are supposed to score answers by looking at the image, so the image should be essential. Remove it and accuracy should crater. Does it?	It barely drops. Removing the image from a VLM judge's input causes only a minimal performance change, revealing that judges largely ignore the image and instead favor the more informative answer, a pattern the paper calls informativeness bias.	text	2604.17768	2604.17768	1
q058fd441	Do advanced proprietary models like GPT-4o actually hold up on specialized medical VQA tasks like identifying clinical conditions and spatial positions?	It performs close to random guessing on these specialized categories, such as identifying conditions and positions.	text	2405.20421	2405.20421	5
q6b1ebb32	Does latent-space decoding actually work for recommendation when handling completely cold-start items with zero interaction history?	No, it can only process items with at least one interaction and cannot handle fully cold-start items with zero interaction history.	text	2509.11524	2509.11524	2
q473d9b6a	For a real-time neural video codec, what limits inference speed more than raw compute (i.e. FLOPs) does?	Operational factors, not compute. Cutting channels drops FLOPs quadratically but inference time falls only about linearly. The real limiters are the latent representation size at high compute and the number of modules at low compute.	text	doc_219ae8e6ce13	2502.20762	2
qe7b9ec18	How should performance degradation be calculated to ensure that comparisons remain robust against floor and ceiling effects from varying baseline scores?	No, they are calculated as the proportion of samples where the degradation is equal to or greater than 5% of the neutral query metric score.	equation	2509.22703	2509.22703	4
q0362d129	When modeling opponents recursively, does an agent's strategy optimize against a distribution over all lower levels or solely against the level immediately below?	It is a pure best response to level k minus 1, the level immediately below.	equation	2402.01521	2402.01521	2
q9efab924	A visual-textual retriever that uses OCR text is distilled into a visual-only student. The text-fed teacher should win everywhere, especially on text-dense academic pages. But does the visual-textual model beat the visual-only one across every document type?	No, it is split. Visual-Textual wins on ArxivQA with MRR 73.67 versus 73.27 and on DocVQA with Recall 96.06 versus 95.74. Visual-Only wins on InfoVQA with Recall 97.61 versus 97.26 and on ChartQA with Recall 80.36 versus 79.53. Visual-Only even edges the average Recall at 87.06 versus 86.93. Distillation closes the gap...	table	2605.24530	2605.24530	4
q84f5e933	Does incorporating a spatial convolutional model improve the retrieval precision of nested entities?	No, it degrades nested entity precision (NEPR) on the ACE2004 and Genia datasets.	table	0e0265f7-1e54-5b4b-ae40-50e79c585bc4	0e0265f7-1e54-5b4b-ae40-50e79c585bc4	3
q33bb527b	My flow-matching generative model keeps producing unstable samples. Would putting a hard cap on the sample velocity (i.e. a relativistic Lorentz bound) actually fix the instability and improve results?	It fixes it and improves results. Bounding sample velocity (ForM) gives far lower distribution-matching loss than unconstrained flow matching on every test distribution (Onedot 0.51 vs ~2.1, Halfmoons 0.71 vs ~5.8, Spiral 0.12 vs ~1.6); the constraint stabilizes sampling and raises quality, not the reverse.	table	doc_015e5d7185eb	2502.08150	14
q8d6a022d	Under the multi-modal gait recognition framework, which modality configuration achieves the highest recognition performance?	On the in-the-wild GREW dataset, Silhouette plus flow gets the highest result on GREW, reaching a rank-1 accuracy of 93.4.	table	2412.11495	2412.11495	6
qfcec02dc	I want to use an LLM to auto-grade which of two model answers is correct on tasks that have a verifiable right answer. Can I trust a strong model to do this reliably?	No. The correctness is barely above chance on hard cases. Even GPT-4o judges at ~50% — no better than random — with a vanilla prompt, rising only to ~56% with a stronger (Arena-Hard) prompt; strong LLM judges stay near coin-flip accuracy on challenging objective comparisons.	text	doc_04a7b3af58a3	2410.12784	7
q05d6f716	Moving graph neural networks to topological domains with multi way relations might seem to require replacing standard message passing with complicated algebraic topology operators. Can this actually be done while keeping something close to standard GNN simplicity?	Yes. Message passing can run over local neighborhood relations such as up and down incidence and up and down adjacency, using a within neighborhood aggregator and a between neighborhood aggregator.	equation	2410.06530	2410.06530	2
qe4c516d8	Does performance on the memorization trap task actually drop when both model parameters and training tokens are scaled up?	Yes, all three factors show significant negative effects with p < 0.001.	table	1a823707-4dc8-5954-8fe1-de9ba161f77a	1a823707-4dc8-5954-8fe1-de9ba161f77a	3
qe91d97b2	LLMs handle high level source code well, which I guess they should also reason fluently over compiler intermediate representations. Where does that break down?	It breaks down at instruction level reasoning. The study finds LLMs can parse IR syntax and spot high level structure, but they consistently struggle with instruction level reasoning, especially control flow reasoning, loop handling, and dynamic execution. Common failures include misreading branches and leaving out ope...	text	2502.06854	2502.06854	8
q715dfaf7	In-context JSON editing is supposed to save tokens compared to regenerating the whole object. Does it still save input tokens as the JSON objects get larger?	No. Input token overhead actually increases as the JSON objects grow larger, which can offset the savings and even hit context window limits.	text	2510.04717	2510.04717	5
q48ec22b5	I want to train in 4-bit to save money, but I'm scared the quality gap to full precision widens as I scale up. Does the 4-bit-vs-full-precision gap actually grow with model size and is 4-bit ever the better one?	It doesn't grow — and it even flips: FP4 is slightly better at 1.3B (perplexity 36.86 vs 37.38) and only marginally worse at 7B (35.62 vs 35.06) and 13B (33.99 vs 33.69); the gap stays ~0.3-0.6 throughout.	table	doc_040712c391e6	2501.17116	5
qc647123b	Low fixed point precision is supposed to hurt alignment accuracy when defending against network alignment attacks. Does it actually degrade the results?	No. Less than 2 percent of the elements are mismatched across all evaluated precisions.	text	2605.04901	2605.04901	6
q0052f8c7	Using a stronger frontier model as the anchor in an LLM-as-a-judge leaderboard is supposed to improve alignment with human rankings. Does upgrading the anchor to o3 actually improve that alignment?	No. o3 actually gets the lowest correlation with human rankings among the anchors tested, fitting an inverted U-shape where both very strong and very weak anchors perform worst.	table	2603.16848	2603.16848	3
q58506dc1	Scaling up model size and training data is supposed to lift how well vision networks predict brain responses. Does that lift apply evenly across the visual hierarchy, from early areas to high level ones?	No, it is uneven. Scaling compute mainly helps high level visual areas such as IT, while early areas like V1 and V2 see minimal gains, and overall neural alignment saturates. Only behavioral alignment keeps improving with more scale.	text	2411.05712	2411.05712	6
q9cbdde65	Combining user persona attributes with historical interaction data is supposed to help preserve minority opinions in iterative recommendation systems. Does it actually do that?	No. It leads to rapid dominance by the majority view and quick suppression of the minority opinion.	text	2510.02360	2510.02360	5
qc947ac71	Cache based test time adaptation only helps if the cached class samples are good. What property of the cache actually predicts whether TTA keeps beating zero shot CLIP under distribution shift?	Intra class compactness of the cached samples predicts it. The paper reports a positive correlation, Pearson r above 0.8 with p equal to 2.25e-3, between TDA's accuracy gain over zero shot CLIP and how compact each class's cached samples are. Gains are large on compact datasets like EuroSAT and small on dispersed ones ...	text	2508.01225	2508.01225	1
q77760894	Does adding dynamic online updates to a hybrid storage system significantly improve retrieval accuracy on long-context tasks?	No. The hybrid storage policy drives most of the accuracy gain, roughly 38.9 to 57 average score. The online update mechanism only adds a small additional gain, around 57 to 60.	table	2509.21623	2509.21623	8
q5b82bb92	In high resolution vision language models that split an image into a global thumbnail plus local crops, does the thumbnail actually do useful work, or is it just extra tokens?	It works as a guide, not just overhead. GlobalCom2 finds thumbnails and crops are complementary, with thumbnails carrying holistic context and crops carrying fine grained detail. It uses the thumbnail as a commander that sets how aggressively each crop gets compressed, keeping over 90 percent of performance while pruni...	text	2501.05179	2501.05179	1
q0f3f8848	A smarter LLM should judge how hard a question is for a human better than a weaker one. As models scale up, does their alignment with human rated difficulty actually improve?	No. The paper finds scaling model size is not reliably helpful for difficulty alignment. Rather than converging on human judgments, stronger models converge toward a shared machine consensus that diverges from students, and high problem solving skill often impedes accurate difficulty estimation.	text	2512.18880	2512.18880	7
q816f7677	A naive time-domain global autocorrelation over a very long series is ON^2, so I'd expect a long-horizon forecasting method to define it via FFT for efficiency. Is this method's global autocorrelation actually formulated in the frequency domain, or as a direct time-domain sum of shifted values?	It is formulated in the time domain. The global autocorrelation R_SSh is defined as a direct time-domain expression, R_SSh = lim_{T->inf} of the summed product of the sequence with its h-shifted copy.	equation	2402.02023	2402.02023	2
q17efaafd	I'd hope my best easy-case optimizer stays best as problems get harder. Does a prompting approach hold up on complex linear programs, or does a fine-tuned model take over?	A fine-tuned model takes over — the prompting framework (Chain-of-Experts) collapses 94.4%→50.6% (~44 points), while the fine-tuned ORLM leads complex at 59.5%.	table	doc_00b0a5cfc068	2508.10047	5
q87d89ecd	For end-to-end driving world models, how much temporal history does the latent world state actually need? Do the strong methods fuse many past frames, or can just the previous frame be enough?	Just the previous frame can be enough. A SOTA method (World4Drive) forms its world latent by cross-attending the current frame with only the immediately prior frame (t−1); despite calling this "temporal aggregation," it reaches state-of-the-art without a long multi-frame history.	equation	doc_06f6facf9ecf	2507.00603	3
q7b4fa736	At moderate sparsity levels with weight decay, does traditional magnitude pruning outperform scale invariant path magnitude pruning?	Yes, at both the 40 percent and 60 percent pruning levels. Magnitude pruning scores 68.8 and 68.2, while path magnitude pruning scores 68.6 and 67.9.	table	2405.15006	2405.15006	8
q84bf593f	In a multi turn search RL run, standard GRPO should keep some exploration alive. Does its policy entropy hold up over training, or collapse early?	It collapses. GRPO's policy entropy starts around 0.75 and drops below 0.1 by roughly step 100, flattening near zero for the rest of the 500 steps, whereas the TSPO variants stay around 0.1 to 0.3.	figure	2601.22776	2601.22776	7
qf779485e	I want to cut my robot-policy training costs by switching to one of these tiny VLAs that claim "comparable" performance to the 7×-bigger models. Realistically, does the small one's training loss actually keep up with the big baseline, or does it lag the whole way?	It lags the whole way. The small model's (EVLA's) loss stays above the larger OpenVLA's throughout and never crosses below; OpenVLA settles around 0.3 while the small one only reaches ~0.5 even after roughly double the steps. "Comparable" is generous — on training loss it's clearly worse.	figure	doc_052f87bbc11b	2507.14049	2
q8cc39c94	Why do independently embedded document chunks retrieve poorly when a query needs document wide context?	Because chunking strips out the semantic and conceptual links between passages. For example, embedding the sentence He became emperor in 1804 without the earlier mention of Napoleon makes it hard to match Napoleon related queries. The ConTEB benchmark shows that top embedding models struggle in exactly this kind of con...	text	2505.24782	2505.24782	2
qfae04d4e	Does the mathematical formulation of the self-distillation loss ($L_{SD}$) incorporate a stop-gradient operator to prevent representation collapse?	No. It directly computes the cosine similarity between the region features and the region crop visual representations.	equation	1216ed9a-5b60-5336-947b-0b186fbc26e2	1216ed9a-5b60-5336-947b-0b186fbc26e2	3
q90dfd6ff	Is the perception weakness of AudioLLMs really an architecture or quantization limit, or a training signal limit that better supervision can fix on the same model?	A training signal limit. Restructuring supervision with the Unified Audio Schema lifts perception on both continuous and discrete models, about 11 percent absolute on MMSU over same size state of the art, while preserving reasoning. This indicates supervision, not architecture, is the bottleneck.	text	2604.12506	2604.12506	1
q7ecc6aa7	Tree-of-Thought is supposed to beat Chain-of-Thought self-consistency on reasoning, but once I fix the token budget on grade-school math, which one actually comes out ahead?	CoT-SC wins. At equal token budget on grade-school math GSM, ToT is only marginally better than plain CoT and actually performs worse than CoT with self-consistency CoT-SC.	text	2404.11041	2404.11041	0
q63071a8c	In the early vision network model, what happens to the neural response as stimulus size increases?	The response is non-monotonic. It rises to a peak around 0.3 degrees and then decreases as the stimulus gets larger.	figure	2506.03089	2506.03089	17
q52a3b9d8	For detecting empathy and distress, which works better, supervised fine-tuning of language models or unsupervised sentence embeddings?	The unsupervised SimCSE RoBERTa model works best, with an average Pearson correlation of 0.352.	text	4d0ae1a6-1249-54c9-ba62-bfc83031aa91	4d0ae1a6-1249-54c9-ba62-bfc83031aa91	2
qcb1a04d8	Differentiating a QP solution by implicit differentiation is supposed to work for any solver that converges in the forward pass. Is there a constraint setup where the linear system this relies on actually breaks down and the gradient becomes ill-defined?	Yes, near weakly active constraints. The analytical Jacobian is built from the set of active inequality constraints. When constraints are only weakly active, the active set becomes unstable, which degrades the gradient quality and can make the underlying linear system degenerate.	text	2410.06324	2410.06324	19
q83c7621d	To reward an RL policy for semantic similarity, could I just use raw embedding cosine similarity as the reward, or does it need thresholding and rescaling so the model cannot exploit the baseline high cosine of random embeddings?	It is thresholded and rescaled, not raw. Cosine similarity below a threshold earns zero reward, and similarities above the threshold are linearly rescaled to a range up to one. This prevents baseline anisotropic similarity from leaking reward.	equation	2605.14366	2605.14366	4
q765ff104	Diff based JSON editing only emits the changes, so it sounds strictly cheaper than rewriting the whole document. Does that hold on tokens, and by how much?	The reported saving is on total usage. Generating RFC 6902 patches with EASE encoding cuts token usage by 31 percent while keeping edit quality within 5 percent of full regeneration, with the largest gains on complex instructions and list manipulations.	text	2510.04717	2510.04717	3
q040c6515	When a method aligns model representations to linguistic feature vectors via a regularizer, I assume the regularization strength is adapted during training. In this base loss, is the linguistic regularization weight adaptive, or just a fixed coefficient in a weighted sum with the task loss?	In the base LinguAlchemy loss it is a fixed coefficient. The total loss is a static linear combination L = lambda_cls * L_cls + lambda_ling * L_ling constant weights, not a dynamically adjusted schedule.	equation	2401.06034	2401.06034	4
q36646080	Finite scalar quantization is compared with vector quantization for reconstruction quality. At what codebook size does finite scalar quantization catch up to vector quantization?	It is near a codebook size of about 512.	figure	5a446602-fd61-5960-a401-e3b92831e1a7	5a446602-fd61-5960-a401-e3b92831e1a7	4
q6bf3bdd4	Does the GPU memory footprint of sparse interaction models scale linearly with increasing input sequence length?	No. The memory footprint stays roughly constant at around 3 GB even as sequence length grows.	figure	2602.01585	2602.01585	6
q1a5440a0	A granularity-aware design should pay off most where fine detail matters, which is the harder high-resolution task. Does its advantage over baselines actually concentrate there, or on the low-resolution task?	Its edge is clearest at low resolution. It tops every low-res split (LR-R 98.11, LR-P 91.07, LR-C 90.20) by a solid margin, but on high-res HR-A it actually trails EarthDial (33.98 vs 34.95). High resolution does not maximize its benefit -- the reverse of the specialized-experts expectation.	table	2512.02517	2512.02517	5
q24ea1d30	Does GRPO actually maintain policy exploration throughout training, or does its policy entropy decay rapidly as steps progress?	It collapses fast. In the baseline, entropy drops below 0.1 by around step 100, while TSPO variants keep entropy much higher and preserve exploration.	figure	2601.22776	2601.22776	7
q7ef0078b	How does the performance of low-light image enhancement change as the number of frequency decomposition scales increases?	It peaks at a specific number. Performance is best with 4 scales, reaching a PSNR of 24.56, and does not keep rising beyond that.	figure	2409.01641	2409.01641	11
qd5c783e0	As vision models like CLIP scale up in capability, does the gap in performance across different world regions actually shrink?	No. The regional disparity more than triples as CLIP models get larger.	text	20b3a035-f42a-5a5c-870b-7036756e10ad	20b3a035-f42a-5a5c-870b-7036756e10ad	6
qd6b7f2f0	Does iterative self-refinement actually hurt translation accuracy when applied to frontier LLMs?	Yes. The refinement process produces a negative change in the accuracy score for these models.	figure	2605.13368	2605.13368	5
q76ab9472	Do agents trained with auxiliary internal rewards consistently outperform those trained only on sparse external feedback during the initial stages of learning?	No. Click-only baselines can match or beat mental-reward agents early on. Mental-reward agents only pull ahead after about 800 steps for SAC and about 15,000 steps for PPO.	figure	2509.22807	2509.22807	8
q947f2ea4	A homography can encode full 3D camera motion, so a rolling-shutter correction model could fold in camera translation as well as rotation. Does its homography formulation actually include translation, or is it rotation only?	Rotation only. The homography is H = K R_dt K^-1, parameterized purely by camera rotation, and the ground-truth motion comes solely from IMU gyroscope rotations with camera translation excluded.	equation	2407.02906	2407.02906	2
q00f0c9da	In diffusion-based style transfer, which noise schedule configuration optimizes the semantic consistency between the generated image and the text prompt?	the Linear schedule	table	32177285-c217-5d70-b17d-ca1c6abf8c9d	32177285-c217-5d70-b17d-ca1c6abf8c9d	7
q1e876964	Does the performance of detecting training data leakage using internal states consistently improve when using deeper model layers instead of earlier ones across different model scales?	No. Layer depth barely matters for Llama-3.1-8B. For Llama-3.1-70B, deeper layers significantly improve accuracy and F1 score.	text	2508.17767	2508.17767	6
qc7c2f68e	I'm scaling test-time compute for a reasoning model and deciding whether to bother with a verifier or just use plain verifier-free SFT. Does it depend on the property of problems?	It depends on how varied the solution approaches are. Verifier-free SFT wins on homogeneous problems (low heterogeneity, +~2.1 accuracy), but verifier-based best-of-N takes over as problems get more heterogeneous, winning by ~2.6 at medium and ~4.7 at high; the verifier pays off more the more varied the problems.	figure	doc_2acd4cfd59a1	2502.12118	14
q685f37e8	I’d intuitively expect probing deeper layers of Llama-3 to steadily improve entity mention detection as the model builds richer semantic representations, but does performance actually scale with depth or is the task already resolved at the very first layer?	No, it does not keep scaling. Maximum performance is nearly reached after the first layer of the transformer.	text	2510.19410	2510.19410	6
q86e20f5c	Does a formal proof language's extensive library help language models prove more Olympiad math theorems, or do different environments still solve the same tiny number?	No, both language environments result in the same absolute number of solved problems (1 problem solved).	table	27377179-ccd7-5643-a4d4-32b139c2bc3b	27377179-ccd7-5643-a4d4-32b139c2bc3b	5
qda8e7de6	Higher-order ODE solvers like Heun beat first-order Euler-Maruyama in theory - but with a learned (imperfect) score network, does Heun still come out ahead on distributional fidelity?	No. With a score network trained on a Gaussian microtexture, the stochastic Euler-Maruyama sampler is more faithful to the data distribution than Heun's method - score-approximation error flips the usual ordering.	text	2405.14250	2405.14250	1
q342f06ee	When a text-to-image model reports how reliably it renders text, how big is the gap between English and a complex logographic script like Chinese?	Essentially no gap, both hit ~94% correct rendering. Chinese caught up via a ~16% improvement over the previous version, reaching parity with English.	text	doc_3643227076f3	2504.11346	13
q1d7f5ebc	Semi-supervised adaptation with pseudo-labels is meant to beat a plain supervised classifier, but under common-class bias, can naive pseudo-labeling actually do worse than just training supervised?	Yes. Naive pseudo-labeling reinforces common-class bias i.e. mislabeling target-private samples as common classes, so a simple supervised classifier can edge out the naively pseudo-labeled semi-supervised model.	text	2403.11234	2403.11234	3
qf9c2d1a0	For text-to-3D scene generation, how much faster can I go without losing visual quality compared with the slower optimization-based methods?	About 15× faster with no quality loss. The accelerated method generates a scene in ~0.72s (≈15× speedup) while still beating the slower baseline on CLIP metrics and user-study win rates.	table	doc_00ecebfe04e0	2504.02261	7
qbffc26ab	Turning a base LLM into an explicit reasoning model is supposed to make it more careful and thus more truthful. When several base models are each converted to their reasoning variant, does truthfulness actually go up, or does it slip?	It slips in every case. Across all five base to reasoning pairs the truthfulness score drops. GLM-4-32B falls from 31.5 to 29.2, GLM-4-9B from 38.4 to 30.4, DPSK-Qwen-14B from 23.6 to 22.8, Qwen3-14B from 23.5 to 23.1, and DPSK-Qwen-32B from 22.8 to 20.8. The decline is consistent, though its size varies from 0.4 to 8....	figure	2512.00412	2512.00412	7

End of preview. Expand in Data Studio

DRPixelBench

DRPixelBench is the benchmark from DR Pixel: Page-Native Deep Research with Vision-Language Models. It has 500 questions over a corpus of 99,055 scientific papers (1,062,153 pages). Each question is grounded in a specific page, often in a table, figure or equation, and has a short answer that can be checked directly against the gold. Finding the evidence usually takes several rounds of search and reasoning.

This repository holds everything the benchmark needs: the questions, the corpus (the paper list, the OCR text and every indexed page as an image) and the page and passage embedding indices. It also holds the training data of the trained DR Pixel model (train/, see Training data). The evaluation harness, search server and training code are in github.com/HughieHu/DRPixel, and the trained model is HughieHu/DR-Pixel-Trained.

How the questions were made

Each question starts from a paper's abstract, which keeps it tied to the paper's main contribution. Because an abstract reports findings with few details, Gemini-3.5-Flash first enriches it with atomic facts extracted from the full paper, such as a comparison in a table or a trend in a figure. The model then writes a question from the enriched abstract alone, locates the supporting evidence in the full paper and writes a short answer. Each question is labeled by the form of its evidence: running text, or a table, figure or equation (the paper's Visual questions).

Every question-answer pair passes four automatic checks: the question is plausible, the gold evidence is sufficient, the non-textual evidence is necessary, and the answer cannot be recovered from parametric knowledge alone. Human experts then review each question and rewrite it to read naturally.

Layout

benchmark/
  eval500.json                         268 KB   the 500 questions
corpus/
  papers.jsonl                         8.9 MB   every paper: doc_id, source, arXiv id, page count
  ocr/part-000 … part-099.jsonl.gz     3.6 GB   OCR text of all 99,055 papers
  ocr/manifest.json                             per-part paper counts, sizes and sha256
  pages/index.jsonl.gz                  18 MB   where each page image is
  pages/shard-00000 … shard-00424.tar  473 GB   every indexed page as a PNG
index/
  page/embeddings.npy                  8.7 GB   page embeddings, one row per body page (Page)
  page/rows.json                        37 MB   row -> paper and page
  text/embeddings.npy                   30 GB   passage embeddings, one row per 256-word chunk (Text)
  text/rows.json                       128 MB   row -> paper and chunk
  text/passages.bin                    6.5 GB   the passage text
  text/passages.offsets.npy             29 MB   byte offsets into passages.bin
train/
  train.jsonl                           28 MB   2,496 training trajectories with per-step loss weights
  image-shards/part-000 … part-003.tar 3.2 GB   the 17,739 page images they reference
  credit/trajectories.jsonl             28 MB   the same trajectories before weighting, with raw credits
  credit/rank_pool.json                0.5 MB   the ranking pools that turn those credits into weights
SHA256SUMS                                      checksums of every file above

You only need the parts your setting uses: Page needs index/page/ and corpus/pages/; Text needs index/text/; training needs only train/. Not included: the source PDFs (see Getting the papers) and the figure-crop index behind the search_figure tool of Text_Fig.

The benchmark: `benchmark/eval500.json`

qid           opaque identifier
question      the question
gold_answer   the reference answer
modality      evidence type: text | table | figure | equation     216 / 135 / 102 / 47
doc, arxiv    the source paper
page          0-based index of the PDF page holding the evidence

Every question is grounded in exactly one page. page uses the same numbering the retriever reports as page_idx, so the two can be compared directly.

The corpus

`corpus/papers.jsonl`

One line per paper:

{"doc_id": "2504.17821", "corpus": "drpixel", "arxiv_id": "2504.17821", "n_pages": 14}

Retrieval hits come back as doc ids, and this file tells you which paper a hit is; an id like doc_f2c81e9eda7d cannot otherwise be traced to a paper. corpus says where the paper comes from (see Corpus composition).

`corpus/ocr/`

{"doc_id": "...", "title": "...", "text": "...", "pages": [{"page_idx": 0, "text": "..."}, ...]}

One JSON object per line, one line per paper. Every PDF was parsed with MinerU into typed blocks and linearised in reading order. Equations are kept as LaTeX, tables as HTML with their captions, and figures are represented by their captions; page numbers, headers and footers are dropped. text is the whole-paper text that the Text passages are cut from. pages holds per-page text for all 2,066,320 pages with OCR content, and the page index covers the 1,062,153 body pages among them.

`corpus/pages/`

Every body page in the page index as a PNG, rendered exactly as the agents in the paper saw them. Each tar member is <doc_id>/<page_idx>.png, and pages are stored in the row order of the page index, so shard k holds rows 2500·k to 2500·k + 2499. index.jsonl.gz has one line per row:

{"row": 0, "doc_id": "doc_000212e3e32f", "block_row": 0, "page_idx": 0, "shard": "corpus/pages/shard-00000.tar", "offset": 512, "size": 254889}

offset and size locate the PNG bytes inside the shard, so a single page can be read without unpacking anything. Two pages could not be rendered from their source PDF (doc_5498c5ec8cc1, pages 8 and 9), and their entries have size 0.

import gzip, json
from huggingface_hub import hf_hub_download

REPO = "HughieHu/drpixel-bench"
index = [json.loads(l) for l in gzip.open(hf_hub_download(REPO, "corpus/pages/index.jsonl.gz", repo_type="dataset"), "rt")]

e = index[row]                       # row = a hit from the page embedding index
with open(hf_hub_download(REPO, e["shard"], repo_type="dataset"), "rb") as f:
    f.seek(e["offset"])
    png = f.read(e["size"])

Each page was rendered with PyMuPDF 1.27.1 at 150 dpi (Matrix(150/72, 150/72)), without a pixel cap, and saved as PNG. This is the same call the search server makes, and before uploading we checked sampled pages byte for byte against the server's own renderer. Please do not downscale or re-encode the images: resolution changes the scores, so a run served at lower resolution is not comparable to the paper's numbers.

The indices

`index/page/`

embeddings.npy   float16, L2-normalised, one row per body page (1,062,153 x 4096)
rows.json        [[doc_id, corpus, block_row], ...]   row i -> entry i

block_row is the position among a paper's body pages, not the PDF page number. The two are the same for all but 19 papers, whose body pages skip some PDF pages; corpus/pages/index.jsonl.gz maps every row to its page_idx and to its image.

The embeddings were computed with Qwen3-VL-Embedding-8B from the same renders capped at 602,112 pixels. The cap applies only to building the index; the agent reads the uncapped render in corpus/pages/.

`index/text/`

embeddings.npy           float16, one row per chunk (3,624,786 x 4096), Qwen3-Embedding-8B
rows.json                [[doc_id, corpus, chunk_idx], ...]   row i -> chunk i
passages.bin             chunk text, UTF-8, concatenated
passages.offsets.npy     byte offsets into passages.bin (n_rows + 1)

Chunks are cut from each paper's text in corpus/ocr/: strip the front matter, collapse blank lines, split on whitespace and cut every 256 words. Each chunk was embedded with the prefix paper_title: "<title>", and passages.bin stores it without the prefix. The search server returns at most 2,200 characters of a chunk, just above the 90th percentile of chunk length. Chunking corpus/ocr/ this way reproduces passages.bin exactly, which we checked on 2,000 papers.

Getting the papers

Every indexed page is in corpus/pages/, so Page needs no PDFs.
We do not redistribute the PDFs. corpus/papers.jsonl gives an arXiv id for 76.3% of the corpus, and those can be downloaded from arXiv directly. The other 23.7% are the external-benchmark papers below, which keep their own identifiers, and 9,565 papers whose arXiv id we did not record.

Papers from other benchmarks

The corpus combines papers we collected from arXiv and open-access conference proceedings with the papers of three existing benchmarks, so that all four benchmarks share one corpus. Those 13,946 papers (14.1%) are included in full so that the corpus is complete, but they belong to their authors and to the original releases. Please cite those releases:

`corpus`	papers	where to get them	cite
`airqa`	13,701	HF `OpenDFM/AirQA` (`papers/<venue>/<uuid>.pdf`)	AirQA, arXiv:2509.16952
`irpapers`	165	HF `weaviate/IRPAPERS`	IRPAPERS, arXiv:2602.17687
`m3sciqa`	80	arXiv, using the ids in the benchmark's own files	M3SciQA, arXiv:2411.04075

Corpus composition

`corpus`	papers	arXiv id known
`drpixel`	85,109	75,544
`airqa`	13,701	0
`irpapers`	165	0
`m3sciqa`	80	80
total	99,055	75,624 (76.3%)

drpixel marks the papers we collected from arXiv and open-access conference proceedings; the other three mark the papers of the external benchmarks. The same label appears in corpus/papers.jsonl and in both rows.json files. An arxiv_id of null means we could not resolve one, not that the paper is absent from arXiv.

Metric conventions

PgHit is the share of questions whose gold page was retrieved. Every question has a gold page, so in the page setting it is taken over all 500 questions.
Acc|Pg is accuracy conditioned on the gold page. Conditioning on the gold paper instead gives a different denominator and a number that is not comparable.
Tool/q counts searches only; the final answer is not a tool call.
A text-only retrieval setting cannot record a page hit, because a 256-word chunk carries a chunk index rather than a page number, so PgHit is not measurable there rather than 0%.

Training data: `train/`

train/train.jsonl is the training set of the trained DR Pixel model: 2,496 trajectories of GPT-5.4 acting as the DR Pixel agent, with the per-step loss weights from counterfactual credit reweighting, exactly as used to fine-tune Qwen3.6-27B. Each trajectory is a run on a training question. The training questions come from the same pipeline as the benchmark, taken before human annotation, over a disjoint pool of papers: no paper that supports a training question supports a benchmark question. Only runs that reached a correct final answer were kept.

hf download HughieHu/drpixel-bench --repo-type dataset --include "train/*" --local-dir drpixel
cd drpixel/train && for t in image-shards/*.tar; do tar -xf "$t"; done     # creates images/

The image paths in train.jsonl are relative to train/, so extract the shards there. The page images are stored as they were used in training: the recipe caps every image at 602,112 pixels, and in long trajectories the images of earlier steps are stored at a half, a quarter, an eighth or a sixteenth of that, so that the whole trajectory fits the training length.

One chat-format trajectory per line:

{"messages": [{"role": "system", "content": "..."},
              {"role": "user", "content": "QUESTION: ..."},
              {"role": "assistant", "content": "<think>...</think>", "loss_scale": 0.84},
              {"role": "assistant", "content": "<call_tool name=\"search_page\">...</call_tool>", "loss_scale": 1.31},
              {"role": "tool", "content": "<tool_output><page id=P0_0 doc=... page=4><image>...</tool_output>"},
              ...,
              {"role": "assistant", "content": "<think>...</think><answer>...</answer>", "loss_scale": 1.5}],
 "images": ["images/<hash>.jpg", ...]}

Retrieved pages arrive as tool turns, with each page image marked <image> in the order of images. Each assistant turn of a search step is split into its reasoning and its action, and each part carries its own loss_scale. The counterfactual credit of the step is converted to a rank-based weight, where 0 masks the step and the largest weight is 2. A reasoning step is kept only if its action is kept and it raises the likelihood of that action at least as much as the median reasoning step does. The final answer has weight 1.5.

credit/trajectories.jsonl holds the same trajectories before weighting, in the same order and with the same text and image paths. Search steps carry their raw counterfactual credits, cf_query for the search and cf_think for its reasoning, and na_think, the gain in the action's likelihood from the reasoning over an empty reasoning block, all computed under the frozen Qwen3.6-27B. The scripts in the training code rebuild the training set from it without a GPU; run them in train/:

python make_weights.py --shards credit/trajectories.jsonl --rank_pool credit/rank_pool.json --out weighted.jsonl
python split_think.py  weighted.jsonl split.jsonl
python build_train.py  --split split.jsonl --out train.jsonl

train/README.md in the code repository shows how to train on this data and how the weights were computed.

License

The questions, answers and annotations in benchmark/ are released under CC BY 4.0. The papers' text and page images in corpus/ are reproduced for research use; copyright stays with their authors, and the papers from AirQA, IRPAPERS and M3SciQA remain under the terms of those releases. The training trajectories in train/ are released for research under CC BY 4.0, subject to the terms of the model that generated them; their page images are reproduced from the source papers like the corpus. If you are an author and would like a paper removed, please open a discussion on this repository.

Citation

@misc{hu2026drpixel,
  title  = {DR Pixel: Page-Native Deep Research with Vision-Language Models},
  author = {Hu, Tiansheng and Wang, Yichuan and Talwar, James V. and Tomlin, Nicholas and Zhao, Chen and Min, Sewon},
  year   = {2026}
}