Datasets:

dwzhu
/

PaperBananaBench

id stringlengths 6 8	split stringclasses 1 value	category stringclasses 4 values	content stringlengths 259 87k	visual_intent stringlengths 30 1.52k	path_to_gt_image stringlengths 48 161	source_pdf stringlengths 33 146	diagram_page_num int32 1 9	method_section_title stringlengths 6 73	width int32 820 1.12k	height int32 378 805	rounded_ratio stringclasses 3 values
test_0	test	agent_reasoning	# 3 Reducing zs-POSGs to Transition-Independent zs-SGs This section presents the main contribution of this work: a lossless reduction from any zs-POSG to a strategically equivalent transition-independent zs-SG. The reduced model preserves the value function, equilibrium structure, and information constraints of the or...	Figure 2: An influence diagram of a transition-independent, two-player, zero-sum stochastic game.	images/(varepsilon)-Optimally Solving Two-Player Zero-Sum POSGs_diagram.jpg	(varepsilon)-Optimally Solving Two-Player Zero-Sum POSGs.pdf	4	3 Reducing zs-POSGs to Transition-Independent zs-SGs	961	570	16:9
test_1	test	vision_perception	# 4.2 4DGS-1K for Fast Dynamic Scene Rendering Building on the analysis above, we introduce 4DGS-1K, a suite of compression techniques specifically designed for 4DGS to eliminate redundant Gaussians. As shown in Figure 3, this process involves two key steps. First, we identify and globally prune unimportant Gaussians ...	Figure 3: Overview of 4DGS-1K. (a) We first calculate the spatial-temporal variation score for each 4D Gaussian on training views, to prune Gaussians with short lifespan (The Red Gaussian). (b) The temporal filter is introduced to filter out inactive Gaussians before the rendering process to alleviate suboptimal render...	images/1000+ FPS 4D Gaussian Splatting for Dynamic Scene Rendering_diagram.jpg	1000+ FPS 4D Gaussian Splatting for Dynamic Scene Rendering.pdf	5	4.2 4DGS-1K for Fast Dynamic Scene Rendering	875	378	21:9
test_2	test	science_applications	# 2 Transition Aware Representation Learning One proof attempt can generate large amounts of data. We found a single pass of ReProver on the miniF2F-valid benchmark of 244 proofs results in approximately 500,000 transitions, capturing rich information about the error likelihood, execution time and resulting proof stat...	Figure 2: Our COMBINED architecture for learning transition aware tactic embeddings. The tactic t and goal g are concatenated and passed through the Encoder $E$ . A representation vector $\mathbf { e }$ is generated by mean-pooling over the tactic token embeddings $\mathbf { t } ^ { \prime }$ . The Predictor $P$ takes ...	images/3D-Prover Diversity Driven Theorem Proving With Determinantal Point Processes_diagram.jpg	3D-Prover Diversity Driven Theorem Proving With Determinantal Point Processes.pdf	4	2 Transition Aware Representation Learning	875	486	16:9
test_3	test	vision_perception	# 3 Method Given a posed monocular video, 4DGT uses a transformer to predict a set of 4DGS, which can be rendered in real time. We first describe the architecture and dynamic scene representation in section 3.1. To enable efficient training and rendering at scale, we introduce a pixel density control strategy and a le...	Figure 2: An overview of our method in training and rendering. 4DGT takes a series of monocular frames with poses as input. During training, we subsample the temporal frames at different granularity and use all images in training. We first train 4DGT to predict pixel-aligned Gaussians at coarse resolution in stage one....	images/4DGT Learning a 4D Gaussian Transformer Using Real-World Monocular Videos_diagram.jpg	4DGT Learning a 4D Gaussian Transformer Using Real-World Monocular Videos.pdf	4	3 Method	1,097	500	21:9
test_4	test	science_applications	# 2 Approach # 2.1 Data NDT3 models datasets of paired neural spiking activity and behavior (Fig. 2). Given our focus on motor decoding, most of the data comes from devices implanted in motor cortex of various monkeys and humans (Fig. 2A). These devices are intracortical multielectrode arrays or probes that record $3...	Figure 2. NDT3 Data and Model Design: A. NDT3 models paired neural spiking activity and behavioral covariate timeseries. We plot the distribution of 2000 hours of pretraining data by subjects (top) and covariate dimensionality (bottom). B. Examples of the neural and behavioral data for each of the three types of behavi...	images/A Generalist Intracortical Motor Decoder_diagram.jpg	A Generalist Intracortical Motor Decoder.pdf	3	2 Approach	1,106	488	21:9
test_5	test	vision_perception	# 3 Minimalistic multi-task image restoration architecture Our proposed MINI architecture is illustrated in Figure 2(a). As shown, the design is remarkably simple and intuitive, and can be built upon any existing image restoration backbone. The only modifications required are to replace the standard convolutions in th...	Figure 2: An overview of the MINI architecture. MINI can be built upon any existing image restoration backbone by simply replacing the original convolutional layers with our proposed MINIconv and introducing a lightweight degradation query mechanism. Subfigure (b) shows the structure of MINIconv, which consists of only...	images/A Minimalistic Unified Framework for Incremental Learning across Image Restoration Tasks_diagram.jpg	A Minimalistic Unified Framework for Incremental Learning across Image Restoration Tasks.pdf	4	3 Minimalistic multi-task image restoration architecture	992	525	16:9
test_6	test	generative_learning	# 4 Approaches for Incorporating Symmetry in Diffusion Policy In this section, we introduce three practical approaches for incorporating symmetry into diffusion policies without requiring complex end-to-end equivariant architecture design. First, we examine how invariant action and perception representations naturally...	Figure 2: The difference comparing our method (middle) with the original Diffusion Policy (left) and the Equivariant Diffusion Policy (right). We use only an eye-in-hand image as the input, and use an equivariant encoder to acquire symmetry-aware features from the input image. In policy denoising, the noisy action and ...	images/A Practical Guide for Incorporating Symmetry in Diffusion Policy_diagram.jpg	A Practical Guide for Incorporating Symmetry in Diffusion Policy.pdf	4	4 Approaches for Incorporating Symmetry in Diffusion Policy	1,111	700	3:2
test_7	test	science_applications	# 4 Predictive Task-aware Self-supervised Learning In this section, we would like to shed light on the downstream label generation process, then propose our SSL method, namely Task Vector Estimation (TVE), based on the label generation insights. Finally, we establish the benefits of this SSL objective over other metho...	Figure 2: Construction of task vectors from relational schema. From schema graph, we derive a schema traversal graph, where edges represent valid join keys. For each reachable table $R$ in $k$ -hop from the source node $v$, we apply a set function $S$ to the set of next-window values $\mathbf { \Sigma } _ { R } ^ { k }...	images/A Pre-training Framework for Relational Data with Information-theoretic Principles_diagram.jpg	A Pre-training Framework for Relational Data with Information-theoretic Principles.pdf	4	4 Predictive Task-aware Self-supervised Learning	917	392	21:9
test_8	test	generative_learning	# 2 Our Methods # ![](images/22c19ac793f7b4a7f01398b76ee0e01201ab7aac83564aa842f1c28fa2d1b473.jpg) Figure 2: Pilot experiments of Category Diversity. In Part A&B, we explore the significant difference in Category Diversity between samples. In Part C, we ascertain two critical selection factors and the potential int...	Figure 1: PCBAs optimization by components with collaborative sample selection and triggers.	images/A Set of Generalized Components to Achieve Effective Poison-only Clean-label Backdoor Attacks with Collaborative Sample Selection and Triggers_diagram.jpg	A Set of Generalized Components to Achieve Effective Poison-only Clean-label Backdoor Attacks with Collaborative Sample Selection and Triggers.pdf	2	2 Our Methods	1,088	628	16:9
test_9	test	generative_learning	"# 2 Proposed Machine Learning Approach\n\nThis paper presents a unified approach for finding paths (...TRUNCATED)	"Figure 1: Proposed ML solution for Rubik’s cube solving: (a) proposed multi-agent solver’s proc(...TRUNCATED)	images/A machine learning approach that beats Rubik's cubes_diagram.jpg	A machine learning approach that beats Rubik's cubes.pdf	4	2 Proposed Machine Learning Approach	1,111	708	3:2

End of preview. Expand in Data Studio

PaperBananaBench

📄 Paper (arXiv:2601.23265) · 🤗 Paper page · 💻 Code · 🌐 Project page · 🍌 Demo

Example diagrams and plots generated by PaperBanana
Example methodology diagrams and statistical plots generated by PaperBanana.

PaperBananaBench is the benchmark introduced with PaperBanana: Automating Academic Illustration for AI Scientists (ICML 2026, spotlight). It evaluates how well a system can turn the text of a paper into a publication-ready illustration. It has two tasks:

Task	Input	Target	`test`	`ref`	Source
Methodology diagram (`diagram`)	method-section text + figure caption	human-drawn method diagram	292	298	NeurIPS 2025 papers
Statistical plot (`plot`)	tabular data (JSON) + short visual description	human-written plot (image + Matplotlib code)	240	240	repurposed from ChartMimic

The test split is for evaluation. The ref split is a disjoint reference pool that PaperBanana's Retriever agent draws in-context examples from. Do not use test samples as references.

Dataset Details

Methodology diagrams (`diagram`)

Built from NeurIPS 2025 papers (paper, Sec. 4.1):

Collection and parsing. 2,000 papers were randomly sampled from the 5,275 NeurIPS 2025 publications. MinerU extracted the methodology section text, all diagrams, and their captions.
Filtering. Papers without a methodology diagram were dropped (1,359 left). Diagrams were then kept only if their aspect ratio (w:h) was in [1.5, 2.5].
Categorization. Gemini-3-Pro assigned each diagram to one of four classes: Agent & Reasoning, Vision & Perception, Generative & Learning, Science & Applications.
Human curation. Annotators verified and corrected the method text and captions, checked the categories, and removed low-quality diagrams. The remaining samples were randomly split into test (292) and ref (298).

Test-set statistics: the source context averages 3,020.1 words and the caption 70.4 words (recomputed from diagram/test.json, matching the paper).

Category and width-height ratio distribution of the diagram test set
Diagram test set (292 samples): category shares and width:height ratio distribution (paper, Figure 3). Recomputing the ratio split from test.json gives 40.4% / 59.6%.

Category (`category`)	test	ref
`agent_reasoning`	92	91
`vision_perception`	73	80
`generative_learning`	73	77
`science_applications`	54	50

Target aspect ratio (`rounded_ratio`)	test	ref
21:9	174	141
16:9	91	119
3:2	27	38

Statistical plots (`plot`)

Raw data behind published plots is rarely available, so the plot task repurposes ChartMimic. ChartMimic pairs plots from arXiv papers and Matplotlib galleries with human-written Python code. Gemini-3-Pro extracted the underlying tabular data from the code and wrote a short description of each plot. After filtering and sampling (paper, Appendix D), 240 test and 240 reference cases remain. They are stratified across 7 categories and 2 difficulty levels.

Category (`category`)	test	ref
`bar`	40	40
`line`	40	40
`scatter`	40	40
`tree_pie`	40	40
`misc`	40	40
`heatmap`	20	20
`radar`	20	20

Difficulty (difficulty): test has 168 hard and 72 easy; ref has 160 hard and 80 easy.

Dataset Structure

Data fields: `diagram`

Field	Type	Description
`id`	string	Sample id, e.g. `test_0`, `ref_1` (ids are not contiguous)
`split`	string	`test` or `ref`
`category`	string	One of the 4 diagram categories above
`content`	string	Methodology section text (Markdown, may contain LaTeX), extracted with MinerU and human-corrected
`visual_intent`	string	The original figure caption, used as the communicative intent
`image`	image	Ground-truth human-drawn diagram (JPEG)
`path_to_gt_image`	string	Relative image path inside the original zip (`images/<paper title>_diagram.jpg`)
`source_pdf`	string	File name of the source paper PDF (see PaperBananaDiagramPDFs)
`diagram_page_num`	int	Page of the PDF where the diagram appears
`method_section_title`	string	Title of the extracted method section
`width`, `height`	int	Pixel size of the ground-truth diagram
`rounded_ratio`	string	Aspect ratio bucket used as the generation target (`21:9`, `16:9`, `3:2`)

Data fields: `plot`

Field	Type	Description
`id`	string	Sample id
`category`	string	One of the 7 plot categories above
`original_category`	string	ChartMimic's finer-grained category (e.g. `errorbar`, `PIP`, `quiver`, `3d`)
`difficulty`	string	`easy` or `hard`
`content`	string	JSON-encoded tabular data, e.g. `{"Year": [...], "Revenue": [...]}`. Use `json.loads`
`visual_intent`	string	Short natural-language description of the desired plot, including target figure size
`image`	image	Ground-truth plot (JPEG)
`path_to_gt_image`	string	Relative image path inside the original zip
`gt_code`	string	Ground-truth Matplotlib code (from ChartMimic)
`width`, `height`	float	Target figure size in inches (Matplotlib `figsize`)
`rounded_ratio`	string	Aspect ratio bucket

Example (`diagram`, test)

{
  "id": "test_0",
  "split": "test",
  "category": "agent_reasoning",
  "content": "# 3 Reducing zs-POSGs to Transition-Independent zs-SGs\n\nThis section presents the main contribution of this work: ...",
  "visual_intent": "Figure 2: An influence diagram of a transition-independent, two-player, zero-sum stochastic game.",
  "path_to_gt_image": "images/(varepsilon)-Optimally Solving Two-Player Zero-Sum POSGs_diagram.jpg",
  "source_pdf": "(varepsilon)-Optimally Solving Two-Player Zero-Sum POSGs.pdf",
  "diagram_page_num": 4,
  "method_section_title": "3 Reducing zs-POSGs to Transition-Independent zs-SGs",
  "width": 961, "height": 570, "rounded_ratio": "16:9"
}

How to use

With 🤗 Datasets (viewer-friendly parquet)

from datasets import load_dataset
import json

diagrams = load_dataset("dwzhu/PaperBananaBench", "diagram")  # splits: test, ref
plots = load_dataset("dwzhu/PaperBananaBench", "plot")

ex = diagrams["test"][0]
ex["image"]          # PIL.Image of the human-drawn diagram
ex["content"]        # method section text
ex["visual_intent"]  # caption

table = json.loads(plots["test"][0]["content"])

With the PaperBanana codebase (original layout)

The GitHub code reads the original zip layout. Download it and unpack it under data/:

huggingface-cli download dwzhu/PaperBananaBench PaperBananaBench.zip --repo-type dataset --local-dir data
cd data && unzip PaperBananaBench.zip && cd ..

data/PaperBananaBench/
├── diagram/
│   ├── images/        # ground-truth diagrams
│   ├── test.json      # 292 samples
│   └── ref.json       # 298 samples (retrieval pool)
└── plot/
    ├── images/
    ├── test.json      # 240 samples
    └── ref.json       # 240 samples

In the JSON files, additional_info holds the per-task metadata that the parquet files expose as top-level columns (file_name, file_path, diagram_page_num, method_section_title, width, height, rounded_ratio for diagrams; gt_code, width, height, rounded_ratio for plots).

The original PDFs of the diagram papers are in a separate repo, dwzhu/PaperBananaDiagramPDFs (5.26 GB zip).

Evaluation protocol

PaperBananaBench uses referenced VLM-as-a-Judge scoring (paper, Sec. 4.2). For each test sample, a VLM judge sees the source text, the caption, the human diagram, and the generated diagram. It decides Model wins / Human wins / Tie on each of four dimensions:

Faithfulness: consistency with the method text and the caption.
Conciseness: focuses on core information without visual clutter.
Readability: intelligible layout, legible text, no excessive line crossings.
Aesthetics: matches the stylistic norms of academic papers.

These outcomes map to 100 / 0 / 50. The Overall score is hierarchical. Faithfulness and readability are primary: if they produce a decisive winner (it wins both, or wins one and ties the other), that winner wins overall. Otherwise the same rule is applied to conciseness and aesthetics. A score of 50 means parity with the human-drawn figure. The paper uses Gemini-3-Pro as the judge. Agreement checks (Kendall's τ on 50 samples) are reported in Sec. 5.2.

Judge prompts are in prompts/diagram_eval_prompts.py and prompts/plot_eval_prompts.py. The scoring logic is in utils/eval_toolkits.py. The full generation pipeline is run with main.py (see the GitHub README for options).

Results (from the paper)

Methodology diagrams, test split (292). Judge: Gemini-3-Pro. Human reference = 50 (paper, Table 1):

Method	Faithfulness	Conciseness	Readability	Aesthetics	Overall
GPT-Image-1.5 (vanilla)	4.5	37.5	30.0	37.0	11.5
Nano-Banana-Pro (vanilla)	43.0	43.5	38.5	65.5	43.2
Few-shot Nano-Banana-Pro	41.6	49.6	37.6	60.5	41.8
Paper2Any (w/ Nano-Banana-Pro)	6.5	44.0	20.5	40.0	8.5
PaperBanana (w/ GPT-Image-1.5)	16.0	65.0	33.0	56.0	19.0
PaperBanana (w/ Nano-Banana-Pro)	45.8	80.7	51.4	72.1	60.2
Human	50.0	50.0	50.0	50.0	50.0

PaperBanana uses Gemini-3-Pro as the VLM backbone in all rows.

Case study: human, Nano-Banana-Pro and PaperBanana diagrams for the same input
Case study from the paper's appendix: the human-drawn diagram vs. vanilla Nano-Banana-Pro vs. PaperBanana, given the same source context and caption.

Statistical plots, test split (240): vanilla Gemini-3-Pro vs. PaperBanana, scored against the human plots (paper, Figure 4).

Plot task scores by dimension for Vanilla, PaperBanana and Human

Notes on the parquet version

The parquet files are built from PaperBananaBench.zip (kept in this repo for the GitHub code).
In the zip, 9 diagram image filenames are mis-encoded, so their path_to_gt_image does not resolve (test_65, test_81, test_149, test_205, test_269, test_281, ref_71, ref_284, ref_309). The parquet files fix this, so every sample includes its image.
ref_1 has split corrected from "re f" to "ref" in the parquet files.
Two diagram reference samples (ref_260, ref_305) have empty content.

Intended use and limitations

Intended for research evaluation of academic-illustration generation systems, and as a retrieval pool for in-context examples (ref).
The diagram data comes from NeurIPS 2025 papers. It covers only AI/ML methodology diagrams with landscape aspect ratios (w:h in [1.5, 2.5]).
VLM-as-a-Judge scores depend on the judge model. Report the judge you used.
Diagrams and method text are reproduced from published papers, and copyright stays with their authors. If you are an author and want a sample removed, please open an issue on GitHub.

License

Released under the Apache-2.0 license, the same as the PaperBanana code. The plot subset is derived from ChartMimic (Apache-2.0). Diagrams and text excerpts come from published NeurIPS 2025 papers, and their copyright remains with the original authors.

Citation

@article{zhu2026paperbanana,
  title={PaperBanana: Automating Academic Illustration for AI Scientists},
  author={Zhu, Dawei and Meng, Rui and Song, Yale and Wei, Xiyu and Li, Sujian and Pfister, Tomas and Yoon, Jinsung},
  journal={arXiv preprint arXiv:2601.23265},
  year={2026}
}

Downloads last month: 4,663

Spaces using dwzhu/PaperBananaBench 16

Paper for dwzhu/PaperBananaBench

PaperBanana: Automating Academic Illustration for AI Scientists

Paper • 2601.23265 • Published Jan 30 • 230