Text2Arch: A Dataset for Generating Scientific Architecture Diagrams from Natural Language Descriptions
Authors: Shivank Garg
Sankalp Mittal
Manish Gupta
Venue: ICLR 2026 Poster (2026)
Keywords: NLP: Generation
NLP: Applications
Primary area: applications to computer vision, audio, language, and other modalities

Abstract: Communicating complex system designs or scientific processes through text alone is inefficient and prone to ambiguity. A system that automatically generates scientific architecture diagrams from text with high semantic fidelity can be useful in multiple applications like enterprise architecture visualization, AI-driven software design, and educational content creation. Hence, in this paper, we focus on leveraging language models to perform semantic understanding of the input text description to generate intermediate code that can be processed to generate high-fidelity architecture diagrams. Unfortunately, no clean large-scale open-access dataset exists, implying lack of any effective open models for this task. Hence, we contribute a comprehensive dataset, \system, comprising scientific architecture images, their corresponding textual descriptions, and associated DOT code representations.  Leveraging this resource, we fine-tune a suite of small language models, and also perform in-context learning using GPT-4o. Through extensive experimentation, we show that \system{} models significantly outperform existing baseline models like DiagramAgent and perform at par with in-context learning based generations from GPT-4o. We have added code and data as Supplementary material, and will make them (and models) publicly available on acceptance.

Published as a conference paper at ICLR 2026
TEXT2ARCH: A DATASET FOR GENERATING SCI- ENTIFIC ARCHITECTURE DIAGRAMS FROM NATURAL LANGUAGE DESCRIPTIONS
Shivank Garg
Sankalp Mittal
IIT Roorkee, India
Google, India
shivank gêmfs iitr. ac in
sankalpmitt a alll23 38 30ammmmmmll..............mmmmmmm com
Manish Gupta Microsoft, India
gmanishem.crosoft.coom
ABSTRACT
Communicating complex system designs or scientific processes through text alone is inefficient and prone ambiguity. system that automatically generates sci- entific architecture diagrams from text with high semantic fidelity can be use- ful in multiple applications like enterprise architecture visualization, Al-driven software design, and educational content creation. Hence, in this paper. we focus on leveraging language models perform semantic understanding of the input text description to generate intermediate code that can be processed to gener- ate high-fidelity architecture diagrams. Unfortunately, no clean large-scale open- access dataset exists, implying lack of any effective open models for this task. Hence, we contribute comprchensive dataset, TEXT2ARCH, comprising scien- tific architecture images, their corresponding textual descriptions, and associated DOT code representations. Leveraging this resource, we fine- fine-tune a suite of small language models, and also perform in-context learning using GPT-4o. Through extensive experimentation, we show that TEXT2ARCH models significantly out- perform existing baseline models like DiagramAgent and perform par with in- context learning based generations from GPT-4o. We make the code, data and models publicly available"
INTRODUCTION
In era where complex systems are increasingly described, designed, and communicated through natural language, the ability to automatically translate textual descriptions into precise, semanti- cally faithful architecture diagrams holds transformative potential. Manual diagram creation is time- consuming and can be error- prror-pron. A system which can convert input scientific text descriptions to architecture images could be usefull for many applications as follows. Authors could use it trans- late their method descriptions to architecture block diagrams automatically enabling high quality software documentation, academic research documents, and patent drafts. A text architecture sys- tem can bridge the gap between textual design intent and visual representation, enabling end-to-end Al Al-assisted software engineering. Usage of such systems for enterprise architecture visualization can help in quick and effective understanding of complex enterprise systems. Broadly, such sys- tems can enable automatic generation of educational diagrams from lesson text, enhancing visual learning. Automatic diagram creation tools could also help in quick updates to existing diagrams as text descriptions evolve. Overall -rrehtttrrhi systems have the potential to significantly boost productivity in fields such as education, scientific research, and industry, where clear and structured visual representations are crucial for effective communication and analytical reasoning. They can accelerate ideation, improve collaboration, and reduce ambiguity in technical communication.
!Code: http:///ghhba.cmm/shhaaa2/lell// text2arch-deepsee// httpa//wasaagggaiieeeeeeeeeeeeaa
Models: http:///hugiingfae.coovivwxlll

---

Published as a conference paper at ICLR 2026
18: Conv
ReLU 1x1 Conn
Sigmold
Resampler
Output
#x:1e1 Conv
Original figure: Fig. from from/bttps//ane 2nr [0.01014v]
(b) Figure description:
The image architecture dhagram depicting attention gule mechanism. The dingram with two inputs: (decoding matrix) and (encoding matrix). Both inputs undergo a 1x convolation operation separately, denoted as Wg: Conv and Wx: bx convolutions then added logsther correspodding points. This activation function, Followed by another 1xl convolution operation. The resulting oulpui is then processed through Sigmeid function to gemerate attention coeflicient,
Conv respectively. The outputs
passed through ReLU
resample input encoding module. Finally, the resampled output is multiplied by the attention coefficient produce the linal output of the attention
coefficient
through Resampler
(c) DOT code: digraph {
"abel="Siggodd"1
[label=""utpurr [labet="Ix1 Conv"]: [labet= "Resampler" [label="Wxckdl Conv"): |label="g") g"I:
bel="ReLLU"]: [: 7 [label=""]] "]" "Wglxl Conv"]:
4:8
6:6 0: 1:7 I;
Outpat
Wislxl Conv
Rel1J
1xl Conv
Sigmold
Resampler
g
Wg:1x1 Conv
(d) Generated figure using TEXT2ARCH.
Figure 1: An example from TEXT2ARCH dataset. (a) shows the original figure while (d) shows automatically generated figure using our proposed TEXT2ARCH model. TEXT2ARCH takes the figure description (b) to generate the DOT code (c) which is then compiled to obtain (d). Fig. (d) can be easily modified by a human expert to achieve the correct diagram.
Yet, despite the growing power of large language models (LLMs), the task of generating high-fidelit, scientific architecture diagrams from text is challenging. Unlike natural scene images, diagram gen- eration demands strict semantic alignment, structural coherence, and fine-grained precision. The task remains largely unexplored, primarily due to the absence of high-quality datasets and robust modeling baselines. This paper addresses that gap. In this work, we focus on the novel problem of cor-tt-architecture diagram generation (TEXT2ARCII), where the goal is to generate architec- ture diagrams, composed of labeled nodes and directed edges, directly from natural language figure descriptions.
In recent years, text-to-image models (Nichol et al. 2021: Vahdat & Kautz 2020 Reed et al, 2016). particularly diffusion models (Song al. 2020 Rombach et al. [2022 Saharia et al. (022). have sig- nificantly advanced image generation, enabling the generation of highly realistic images for various industrial applications from simple text prompts (Capogrosso et al. 2024 Li al. 2024). However, they are inherently limited when it comes to structured architecture diagram generation (Rodriguez) al. 2023bla Zala et al. (202)). These models often suffer from short input context windows, e.g., Stable Diffusion's 's use of CLIP restricts input to 77 tokens, and cannot adequately process or reason over long textual inputs. Approaches like LongAlign (Liu et al. 2024b) to extend input capa- bilities, but the core architectural limitations remain. Moreover, diffusion- capture explicit logical structures, often producing diagrams with unreadable or incorrect textual components and poorly organized visual elements. Lastly, it is difficult to edit and further refine such generated images.
models struggle to
Hence, alternative techniques have attempted to convert text descriptions to intermediate code in a graph description language (e.g., TikZ), and then render the code into diagrams using standard compilers like D and TikZ") While effective for simple plots and charts, these methods falter in generating semantically rich and hierarchically organized diagrams. Recent efforts such as Diagra-
hhtn:://www..maaaiiioo///mnnnnnn https:/ggthhh..cm//gff///////
2

---

Published as a conference paper at ICLR 2026
mAgent (Wei et al. 2024) improve diagram synthesis, editing, and reasoning by incorporating both textual and visual modalities. We follow this line of work. However, unlike DiagramAgent, which uses multi-agent framework and a broad benchmark spanning eight diagram types with loosely aligned text-code-image pairs, our proposed TEXT2ARCH system focuses exclusively on scientific architecture diagrams with clean, semantically aligned triplets of textual descriptions, DOT code, and images. Additionally, TEXT2ARCH adopts a streamlined end-to-end approach and introduces rich set of novel graph-level evaluation metries, offering deeper insights into structural fidelity and making it more practical for real-world use.
A core bottleneck in this field is the lack of large-scale, high-quality, open-access dataset that pairs detailed textual descriptions with corresponding architecture diagrams and their structured code representations. Existing datasets like ACI.-Fig (Karishma et al. 2023) and Paper2Fig (Ro-) driguez et al. 2023b) include mix of diagram types, often lack consistent labeling, and do not contain clean, well-aligned textual descriptions specific to architectural content. To address this gap, we introduce TEXT2ARCH, large-scale benchmark dataset consisting of 75, 127 samples of archi- tecture diagram images, their corresponding clean textual descriptions and the corresponding DOT code representations. We leverage GPT-4o prompting, structured diagram parsers well as relevant paragraphs from paper pdfs to obtain clean textual descriptions and the DOT code representations. The dataset is divided into 60, 519 train, 7565 validation and 7043 test samples.
We perform zero-shot inference using GPT-4o as well as smaller models like Qwen2- 7B (Qwen Team, 2024), DeepSeek-llm-7Dbbaal (Liu al., 2024a) and Meta-LLlama-3888 (Dubey iet al. (0024). Using the train set of TEXT2 we develop a family of LLM-basse models (in the 7B-8B parameter range) fine-tuned specifically for the task of generating structured DOT code from natural language input. We also compare the performance with DiagramAgent (Wei et al. 2024). We report performance on the test set of TEXT2ARCH as well as on a human labeled measurement set of 99 images.
Although our end goal is to generate architecture diagrams, TEXT2ARCH generates the DOT code post which we use the standard DOT compiler to generate the image. Hence, it is not very mean- ingful to evaluate the quality of the image. Instead we measure the output quality using two sets of metrics: standard natural language generation (NLG) metrics and graph based metrics. As part of the standard NLG metrics, we use sequence similarity (ROUGE-L), structural and semantic align- ment (CodeBLEU), and edit-based distance (Levenshtein) between the generated DOT code and the ground truth code. We also include character- overlap (chrF) to capture nuanced differences between predicted and reference code. Graph based metrics based on graph representations of predicted and ground-truth diagrams. They include similarity-weiggheee F1 F1-score using optimal node matching via the Hungarian algorithm (Kuhn 1955). We also extend the evaluation to edges through precision, recall, and Jaccard similarity. Additionally, we propose Node PR-AUC by varying the matching threshold to assess robustness across similarity levels.
node precision, recall, and
We make the following main contributions in this paper. (1) We introduce the novel task of generat- ing scientific architecture diagrams from natural language descriptions via intermediate DOT code. (2) To support this, we release TEXT2ARCH, a large-scale dataset of over 75K samples containing architecture images, clean textual descriptions, and corresponding DOT code. Samples are also di- vided into easy, medium and hard buckets. (3) We fine-tune multiple small language models and evaluate GPT-4o for this task, showing significant improvements over existing baselines like Dia- gramAgent. (4) Our evaluation framework includes both standard NLG and graph-level metrics to rigorously assess semantic and structural fidelity.
RELATED WORKS
2.1 SCIENTIFIC FIGURE UNDERSTANDING TASKS
Significant research has been conducted in the domain of scientific document and figure analysis. Most prior works, however, have primarily focused on tasks such as figure classification (Jobin et al.) 2019) figure detection (Roy et al., 2020). figure captioning (Hsu et al.) 202T), and visual question answering and question generation over figures (Kahou et al., 2017) ). For instance, PDFMEF (Wul ct al. 2015) proposed a multi-entity extraction framework designed to identify and extract figures from PDF documents, Similarly, ImageCI.EF (Garcia Seco De Herrera et al. 2015) introduced
3

---

Published as a conference paper at ICLR 2026
benchmark dataset for compound figure detection and separation. PDFFigures (Clark & Divvala 2013) facilitated the extraction of figures and their corresponding captions from research papers. PatentLMM (Shukla et al. (2025) generates high-quality descriptions of patent figures. Recently, Di- agramAgent (Wei et al. 2024) extended this line of work by introducing a multi-agent framework for generating and editing diagrams from textual descriptions, supported by a diverse benchmark across multiple diagram types. In contrast, our work focuses on the task of scientific architecture diagram generation from natural language via intermediate DOT code, contributing a large-scale dataset with clean text-code-imes -magee alignment and robust evaluation framework to advance semantic fidelity in figure understanding.
2.2 SCIENTIFIC FIGURES DATASETS
A range of classification-focsses datasets, such as DocFigure (Jobin et al., 2019). FigureSteer (Siegel et al. 2016), Revision (Savva et al. (01T)) and ACLFig (Karishma et al. 2023). support figure-type classification. FigureQA (Kahou al. 2017) further introduced large-scale dataset of over one million question-answer pairs grounded in synthetic figures such as bar graphs and line charts. However, none of these datasets are tailored to architecture or structured system diagrams.
To address this, SciCap (Hsu et al. 202I) introduced 60,000 figure-text pairs spanning diverse figure types, including flowcharts, equations, and plots. FigCap (Chen et al. 2019) similarly provided captions for a wide range of diagrams. Yet these datasets are highly heterogeneous and include many non-architectural figures, limiting their usefulness for -cchtecctre-speccfic generation. Automatikz (Belouadi et al.] (024a) introduced 120k TikZ drawings with captions, and DeTikkZify (Belouadi al., (024b) expanded this to 360k. Paper2Fig (Rodriguez et al.) (023b) made more focused effort to extract figures and context from research articles, but still contains many irrelevant figures (e.g., plots, tables) and noisy or incomplete text.
To overcome these limitations, we build upon Paper2Fig using extensive filtering and refinement. Specifically, we train image classifiers to retain only architecture-relate diagrams and employ GPT- 4o to generate clean, semantically rich descriptions. This curation produces a high-quality dataset focused exclusively on architecture diagrams with meaningful textual descriptions, suitable for text- to-architecture diagram generation.
3 TEXT2ARCH DATASET CURATION
In this section, we discuss our detailed dataset curation pipeline which is also illustrated in Fig. 2 The pipeline comprises main steps: (1) Training Arch versus no-Arch Classifier, (2) DOT Code generation, and (3) Refining Architecture Image Descriptions.
Arch versus no-Arch Classifier. An image is classified as an architecture diagram visually represents the structural design, components, and relationships within system, model, or process. This includes neural network architectures, software systems (diagrams illustrating mi- croservices, databases, APIs, data pipelines, system architecture), research figures (architecture figures in academic papers that describe model design, experimental setup, or algorithmic flow).
Training
Although there exist multiple datasets with scientific diagrams, most of them do not have architecture diagrams specifically labeled. Hence, we train an arch vs no-arch classifier using a combination of three datasets obtained follows. (1) ACL-Fig dataset (Karishma et al.) 2023) has 1671 scientific figures (with 19 category labels) extracted from 890 research papers. Of these, we considered 103 neural networks and 105 architecture diagrams as positive. We considered remaining classes with 1474 images as negative. (2) SciFig datasef" does not have any labels, but has figure captions. Based on these captions, we identified 6482 images positive examples. An equal number of images were randomly sampled from the remaining dataset to serve as negative examples. (3) Paper2Fig dataset contains 101371 images. We manually labeled 2004 images of which 1239 are positive images and 765 are negative. We keep 1003 of these for test purpose (620 arch and 383 no-arch).
Overall, we obtain a dataset of 7929 arch images and 8918 no-arch images. We use 1003 of Pa- per2Fig manually annotated subset for test purpose (620 arch and 383 no-arch). The remaining
4

---

Published as a conference paper at ICLR 2026
Subset ACL-Fig
Train Image Classification Model
Arch no-Arch classifier
Subset of SciFig
Paper2Fig
Manual Labeling
Paper2Fig +Desc1
Paper2Fig-Arch +Dssc1
Paper2Fig-Arch +Desct+DOT1
GPT
Arch vs no- Arch classifier inference
Florence OCR
Flowcharl Object
Detection
Paper2Fig-Arch +DOT2
Paper2Fig-Arch +DOT3
GPT
Training Arch versus no-Arch Classifier
PDF extractor Relevant para retriever
Text2Arch
2
DOT Code generation
Paper2Fig-Arch +Desc2
Paper2Fig-Arch +Desc3
3 Refining Architecture Image Descriptions
GPT
Figure TEXT2ARCH Dataset Curation
images are stratified split into train and validation so as to maintain the same ratio of arch vs no-arch images train and test.
We train multiple models like CLIP (Radford et al. 2021). ViT Dosovitskiy et al. 2020). BEiT (ao al. 202T). and ResNet (He al. 2016), and report results in Table i in Appendix A We vary learning rate as le-5, 5e-4 and 5e-5. We train for up to 50 epochs and choose the best model based on validation loss. We also perform rotation, horizontal flip and vertical flip data augmentations.
Our best model is CLIP trained with a learning rate of 1e-5. It provides test accuracy of 83.45% after just 2 epochs of training. The precision 0.83, recall 0.92 and Fl is 0.87. An accuracy of 83.45% is competitive given the inherent complexity and variability of scientific figures. More importantly, the high recall of 0.92 indicates that the classifier effective at identifying architccture diagrams, which was primary goal for downstream tasks. The Fl score of 0.87 further supports the model's balanced performance. Inferring this classifier over the entire Paper2Fig dataset gives set of 80486 architecture images.
DOT Code Generation. For training TEXT2ARCH models, our goal was to leverage the large Pa- per2Fig dataset. But it does not have any annotated DOT code. Hence, for each image in the dataset, we need to obtain ground truth DOT Code. Manual labeling is difficult for such large set and hence report
combination of GPT-4o, florence2 OCR (Xiao al. 2024) and Flowchart object detectors to obtain the final DOT code as follows.
First, we use GPT prompt (Appendix E which takes the figure as input and extracts the DOT code representation (called DOTI).
Next, parse the architecture diagram using object detection model from (Shukla al. 2025 The model is trained on top of Faster-RCNN (Ren et al.) 2015) using a dataset of 350 manually annotated patent figures and can extract diagram specific elements like nodes, node labels. figure labels, text and arrows. This model helps us extract nodes and edges for the DOT code. To extract the text representing the node, we use the florence2 OCR model [Xiao et 2024 Direction of arrows was decided based on detected arrow heads. Arrows were linked to nodes closest to start and end of arrow heads. To avoid self loops, we assign end of arrow to second nearest node if the nearest node is already associated with the arrow. We refer to this version of DOT code as DOT2. Further,
Imicrooft//lorennce--laggggf
5

---

Published as a conference paper at ICLR 2026
used GPT-40 to take DOT2+image imput and get refined DOT code (called DOT3). Detailed prompt is in Appendix G Knowing the number of nodes in an image also helps us categorize images into problem complexity buckets: easy (upto 0- nodes), medium (15-24 nodes), hard (25+ nodes).
Refining Architecture Image Descriptions. As an input for TEXT2ARCH, we need a good image description. The Paper2Fig dataset already contains paragraph (called Desc1) extracted from the paper containing the first reference of the figure. Besides this, the Paper2Fig dataset also contains a caption for each figure.
To obtain a more complete description, we first find all paragraphs from the paper text (extracted from the paper pdf using pypdf) which contain the figure reference" Next, compute TF-IDF- based cosine similarity between all candidate paragraphs and a combination of OCR tags and image caption. We retain top paragraphs with highest similarity score from this relevant paragraph re- triever. We combine this with Descl and call it Desc2. Lastly, we use GPT prompt to take the cur- rent image and these top description paragraphs as input and output a revised description (Desc3). See detailed prompt in Appendix F
Overall TEXT2A RCH Dataset. The Paper2Fig dataset subsetted to architecture diagram images along with DOT3 as labels and Desc3 as refined descriptions is further checked to remove entries where Desc3 or DOT3 is empty. We also remove entries where GPT labels images as no-Arch. The final filtered dataset is contribution, referred to as TEXT2ARCH. We split the dataset into train, validation and test stratify by diagram complexity, i.c., the number of nodes. The dataset con- tains 60519 train samples, 7565 validation samples and 7043 test samples, adding overall 75127 samples. Around 54.3% samples are easy, 32.4% are medium and the rest are of hard complexity.
Along with this dataset, set of 99 images is manually labeled by the authors to obtain manually written DOT code. This dataset contains 50 easy, 30 medium and 19 hard images.
- Train Vulidation
Train
8000
Freqietey
1000
Tost
Frequency
1.000
Validation
6000
100
10
20
40
60
30
100
Number of Nodes
Number of eddges
Number of words description
Figure 3: Distribution of number of nodes and edges, and number of words in image descriptions in TEXT2ARCH.
Fig. 3 shows the distribution of number of nodes and edges in the DOT graphs. The distributions very similar across train, validation and test. On average there are 15.24 nodes and 13.89 edges per sample. The figure also shows the distribution of number of words in image descriptions in TEXT2ARCH. On average there are 203 words across these descriptions.
TEXT2ARCH METHODOLOGY
Given a clean input description about a system architecture, the goal of the proposed TEXT2ARCH system is to generate an architecture diagram. More specifically, in this work we focus on translating the natural language description to DOT graph representing the architectural flow of processing in the input text. DOT compilers could then be leveraged to convert the DOT code to a graph. In this section, we discuss various models that we experiment with for TEXT2ARCH. We also propose novel task-specific metrics.
4.1 MODEL ARCHITECTURES AND APPROACHES
We benchmark several methods for the TEXT2ARCH task. First, we compare with the DiagramA- gent method. Second, we compare with direct GPT-4o zero-shot inference. Third, we perform few-
httpss//ppp.orr//oojcccyyyp
Figure number preceded by any of these: Figure, Fig, figure, Figure., Fig., figure., fig. fig

---

Published as a conference paper at ICLR 2026
shot inference with three popular instruction-tuna small language models. Lastly we also finetune three popular small language models.
For GPT-4o inference, we the prompt detailed in Appendix | For few-shot inference, perform inference with the following models: meta- mntt--laaaaMMeta -oatat--llmm------ Instructt (Dubey et al.)
2024). Owen/Qwen2-785 7B-Intrucc (Qwen Team 2024) and beepseek-ai/deeesse--ln---
(Liu
et al. 2024a) using the prompt and the 5 few shot examples as listed in Appendix L We perform few-shot prompting with instruction tuned models because we observed that the pretrained base versions failed to generate any reasonable output. With few shot prompting the pretrained models repeated the few shot examples in the output, or generated an empty output.
for our experiments because they represent the current state-of-the-art among open-weight, instruction- tuned language models that balance performance, accessibility, and efficiency. These models are specifically fine-tuned for cntruuction-oolowinng and code generation tasks, aligning well with the requirements of generating structured DOT code from natural language descriptions. Compared to larger proprietary models, they are more lightweight and can be fine-tuned or deployed in resource- constrained environments. At the same time, they outperform earlier open models (like LLaMA- 2 or GPT-J) on code-related benchmarks, and offer better controllability and interpretability than blx diffusion -assdd rext-to-image models. This combination of strong semantic understand- ing, structured output capabilities, and open accessibility makes them ideal candidates for our task.
We selected Meta-Llamma---88 I-Intructt,,, Qwen2-7B-Insteee
and DeepSeck-LLM--BB-
As mentioned above, perform supervised finetuning (SFT) of the base variants of these models Laaa-llammMMttallaaaae
Qwen/Qwen2-77-bbun and wwtpSeeeeaa//eeeSeeeekkle this prompt: "You are an expert in analyzing technical descriptions of system architecture, work- flows, and process pipelines, and a code design specialist skilled in graph visualization using DOT language."
using
Text Meiries
Graph Metries
ROUGE-L
Code
Edit Dis-
chrl
Node
Node
Node
Node
Edge
Edge
Edge
Edge
Jaccard
BLEU
rance
Prec
Recall
F1
PR-AUC
Prec
Recall
Fl
PR-AUC
Sim.
DiugramAAent
42.2
31.0
680
48.2
60.7
56.5
55.1
20.9
31.7
22.6
24.8
18.0
17.8
GPT
30.8
17.7
730
42.9
71.6
56.5
60.7
27.4
56.3
39.5
44.6
31.6
36.1
Llama-3-8B
34.9
21.5
709
41.0
09.0
56.8
59.7
242
41.5
29.0
32.5
22.0
24.6
Tew-
Funed shot
Qwwez-7B
27.4
19.4
811
30.4
64.9
48.1
32.0
19.8
32.8
212
24.3
13.9
17.2
DeepScek-78
30.4
21.4
1079
31.4
34.1
41.3
43.
17.
25.0
13.6
16.6
13.0
11.3
Llama 3. 8B
28.2
27.8
956
39.8
27.8
45.3
31,9
7.0
22.9
10.2
13.2
9.1
8.4
Pine-
Qwen2-7F 7B
35.0
30.7
975
45.3
33.3
49.8
36.8
8.1
21.8
103
13.7
888
888
DeepSeck-78
46.8
34.5
608
55.7
66.2
69.6
65.7
213
46
342
38.0
23.7
28.0
Table 1: DOT code generation task results on TEXT2ARCH test set. (Best values are in bold. Second best are underlined.)
Text Metries
Graph Metries
ROUGE.
Code
Edit Dis.
chrfi
Node
Node
Node
Node
Fdge
Edge
Edge
Edge
Jaceard
BLEU
Prec
Recall
F1
PR-AUC
Prec
Recall
Fl
PR-AUC
Sim.
DiagramAAget
49.1
40.9
959
55.3
55.0
59.8
54.3
1244
32.0
22.8
25.3
16.9
17.8
GPT
28.2
16.3
790
43.4
69.7
60.1
63.0
28.0
55.9
40.4
46.2
30.9
37.8
Llarma-3-BB
37.3
23.1
54.1
17.0
42.4
28.5
32.5
25.7
Teew-
tuned Sheg
Qwenn2 7B
30.1
220
562
12.0
54.9
50.7
48.9
132
37.1
21.7
25.5
14.9
18.1
DeepScck-78
36.9
28.6
35.8
52.
42.2
42.9
138
275
17.
20.4
13.9
15.4
Ilama 3. 3BB
30.9
46.0
1024
44.0
21.3
46.4
27.5
4.9
27.7
11.9
15.2
14.3
10.1
Fine-
Qwen2-76 7B
40.9
46.3
891
53.1
35.3
37.1
40.2
94
194
11.
14.0
11.8
9.3
DeepSock-7B
55.2
49.3
407
78.1
69.4
39,4
44.6
49.1
35.1
39.8
Table 2: DOT code generation task results on TEXT2ARCH manual annotation set. (Best values are in bold. Second best are underlined.)
4.2 METRICS
For evaluating the TEXT2ARCII task, we assess the generated DOT code using the following stan- dard natural language generation (NLG) metrics as well as the novel graph-basee metrics which we design specifically for the TEXT2ARCH task. The standard NLG metrics include the following, (1) ROUGE-L (f): Measures similarity with the reference code based on the Longest Common Sub- sequence (LCS), focusing recall. (2) CodeBLEU (t): Assesses the semantic and syntactic sim-

---

Published as a conference paper at ICLR 2026
ilarity with reference code, incorporating n-gram matching, Abstract Syntax Tree (AST) matching, and data-flow matching. (3) Edit Distance (L): Computes the Levenshtein distance, representing the minimum number of single-character edits (insertions, deletions, substitutions) required to change the generated code into the reference code. (4) chrF (t): Character n-gram F-score, evaluates text similarity at the character level, making it robust to tokenization differences.
The graph-based evaluation metrics evaluate the structural correctness of the generated diagrams by comparing the underlying graph structures derived from the DOT code. We define the following graph-based metrics suitable to this task. (1) Node Precision, Recall, F1-Score (1): These metrics assess the accuracy of node identification and labeling. Node matching is performed using string similarity between labels (via Hungarian algorithm for optimal assignment), and scores are aggre- gated. (2) Node PR-AUC (Area Under Precision-Recal Curve) (t): Measures the overall perfor- mance of node matching across various similarity thresholds. (3) Edge Precision, Recall (*): Eval- uate the correctness of detected edges between matched nodes. (4) Edge PR-AUC (Area Under Precision-Recct Recall Curve) (1): Measures the overall performance of edges across various similarity thresholds. (5) Jaccard Similarity (Edges) (t): Measures the overlap between the sets edges in the ground truth and predicted graphs, based matched nodes. Detailed definitions of these metrics are included in Appendix
Text Metrics
Gruph Metrics
ROUGE-L
Code
Edit
chrF
Node
Node
Node
Node
Edge
Edge
Edge
Edge PR-AUC
Jaccard
BLEU
Iance
Prec
Recall
FI
PR-AUC
Prec
Recall
B1
Sim.
DOT1
13.8
35.3
1843
37.1
66.1
78.4
67.3
28.3
44.6
31.2
30.2
22.9
DO12 29.1
40.4
422
52.9
13.4
6.2
6.4
TXT3 56.2
49.4
620
68.0
71.0
8835
74.5
33.7
63.0
46.6
51.7
39.5
41.2
Table Comparison of DOT code variants as judged on TEXT2ARCH manual annotation set. Best values are in bold.
5 EXPERIMENTS
5.1 MAIN RESULTS
We first list our main results using automated metries, followed by GPT-based evaluation. we also discuss quality comparison across various DOT and Desc variants. Lastly, we show several examples of generated output from TEXT2ARCH and other models in the Appendix.
Tables I and summarize the performance of various methods on the text-to-DOT code generation task, evaluated on both the TEXT2ARCH test set and the manually annotated set. Note that for computation of these metrics, we used DOT3 variant from TEXT2ARCII dataset as the ground truth. Note that DiagramAgent generates TikZ code rather than DOT code. Hence, we use the prompt detailed in Appendix [H] with GPT-4o to convert the generated TikZ code to DOT.
The results clearly demonstrate the effectiveness of finetuned models over few-shot in-context learn- ing (ICL.) models and GPT. On text-based metrics such as ROUGE-L, CodeBI.EU, Edit Distance, and chrF, finetuned models, particularly the DeepSeek-77 achieve substantial improvements. For example, on the manual annotation set, DeepSeek-7B achieves a ROUGE-L of 55.2 and CodeBLEU of 49.3, significantly outperforming the best few-shot ICL model (Llama-3-8B, ROUGE-L 37.3, CodeBLEU 23.1) and GPT (ROUGE-L 28.2, CodeBLEU 16.3). This indicates that finetuning en- ables the models to generate code that is not only more syntactically and semantically aligned with the ground truth but also more concise and accurate, reflected in lower edit distances and higher chrl scores.
Beyond text similarity, the graph-based metrics provide deeper insights into the structural fidelity of the generated diagrams. Finetuned models and GPT perform better than few-shot ICL models, with DeepSeek-7B achieving the highest node and edge Fl scores (e.g., Node Fl 65.7/69.4 and Edge Fl $8.0/49.1 on the test/manual sets, respectively). These gains also reflected in higher PR- AUC and Jaccard similarity scores, underscoring that finetuning improves not just the surface-level code but also the underlying DOT graph semantics. Performance from few-shot ICL models seems inconsistent: Llama-3-8B and Qwen2-7B few-shot models are better but DeepSeek-77 few-shot models worse compared their finetuned counterparts.
8

---

Published as a conference paper at ICLR 2026
5.2 GPT-40 BASED EVALUATION
Besides automated metric based evaluation, we also perform GPT based evaluation to compare the generated DOT code with both the image and the ground-trui touth DOT code. We ask GPT determine if the structure, labels, node ordering, and relationships in the generated DOT code accurately reflect the image and ground-truth. And then assign compatibility score between and Detailed prompt is in Appendix K
GPT-40 (2.72) and DeepSeek-785 (2.68) outperformed both the DiagramAgent baseline (2.37) and the other 7B-scale models (Qwen2-7B BB at 2.24, Llama-3-8B at 1.90). This subjective assessment mir- rors the objective gains we see in Table [ on text metrics (ROUGE-L, CodeBLEU, chrf) DeepSeek- 7B consistently leads the finetuned group (e.g. ROUGE-L 46.8 vs. 30.8 for GPT, 42.2 for Diagram- Agent), and on graph metrics it achieves the highest node/edge FI and PR-AUC scores.
In short, compared to other small language models and DiagramAgent baseline, the DeepSeek-7B model not only "looks" better to an expert evaluator but also delivers the best syntactic accuracy and structural fidelity across both tables, validating that human judgments align closely with our quantitative benchmarks.
5.3 QUALITY COMPARISON BETWEEN VARIOUS DOT VARIANTS
Table 3 highlights the significant improvements achieved by DOT3 over variants DOTI and DOT2. DOT3 achieves the highest scores across both text-based and graph-base based metrics, with ROUGE-L
56.2, CodeBLEU 49.4, and chrF 68.0, indicating much closer alignment to the ground truth code. On structural metrics, DOT3 shows substantial gains in both node and edge quality, achieving Node F1 74.5 and Edge F1 51.7, compared to DOTI (Node F1 67.5, Edge F1 31.2) and DOT2 (Node Fl 54.6. Edge F1 8.3). These results demonstrate that DOT3 not only preserves the semantic content of the diagrams better than DOT1, but also corrects the structural inconsistencies and low edge quality observed in DOT2. The high Jaccard similarity of 41.2 further confirms that DOT3 captures overall graph topology more faithfully.
These improvements validate the design of our multi-step pipeline for generating high-quality DOT code. DOTI, derived directly from GPT prompting, suffers from incomplete or noisy outputs due to the inherent limitations of language models precise spatial reasoning. DOT2, constructed from object detection and OCR, improves node and text alignment but struggles with edge connectivity and overall coherence, as reflected in its low edge metries. By combining the structural grounding of DOT2 with GPT-based refinement in DOT3, proaches, accurate detection of components and the generative ability of GPT to produce syntacti- cally correct and semantically coherent DOT code. This hybrid strategy proves crucial for producing high-fidelity representations of complex diagrams, as evidenced by the consistent gains across all evaluation metries.
effectively leverage the strengths of both ap-
5.4 QUALITY COMPARISON BETWEEN VARIOUS DESCRIPTION VARIANTS
Using GPT, evaluate whether Desc1 Desc3 is better description for image. Similarly, we evaluate between Desc2 and Desc3. The prompt is detailed in Appendix J We also experimented with positions exchanged in the prompt to eliminate position bias. We found that Desc3 was pre- ferred over both Desc1 and Desc2 over 90% times.
5.5 QUALITATIVE ANALYSIS
We show 3 case studies comparing outputs from various models for the TEXT2ARCH task in Ta- bles 4 to Appendix [D] Our TEXT2ARCH's finetuned DeepSeek-7B consistently demonstrates superior performance in structured diagram synthesis compared to all baseline models. Whether re- constructing neural architectures, algorithmic pipelines, or domain-specific workflows, DeepSeek- 7B excels in both semantic fidelity and structural accuracy. It reliably captures node labels, edge relationships, and even nuanced features like skip connections and module-specific operations. In contrast, baselines such DiagramAgent, GPT. and few-shot DeepSeek variants often produce incomplete, generic, or misaligned outputs. The ground truth DOT codes, when available, are fre- quently noisy under-specified, further highlighting the clarity and precision of DeepSeek-7B's

---

Published as a conference paper at ICLR 2026
outputs. These results underscore the value of fine-tuning for domain-specinne tasks and position DeepSeek-7BB as a robust solution for automated diagram generation in technical and scientific con- texts.
CONCLUSION
In this work, we introduced the novel task of generating scientific architecture diagrams from nat- ural language descriptions via intermediate DOT code, addressing critical gap structured di- agram generation. We contributed TEXT2ARCH, a large-scale, high-quality dataset of over 75K aligned text-code-image triplets, enabling rigorous benchmarking of this task. Through extensive experiments, demonstrated that fine-tuned small language models significantly outperform both few-shot in-context learning and existing baselines like DiagramAgent, achieving superior syntac- tic accuracy and structural fidelity. Our proposed evaluation framework, combining text-level and graph-level metrics, provides a comprehensive assessment of both semantic and structural correct- ness. Notably, the fine-tuned DeepSeck-7B model emerged the most effective, closely matching GPT-4o in evaluations on the human-generated test set while being open and lightweight. These findings highlight the importance of domain-specifee fine-tuning and structured evaluation in ad- vancing text-to- arthhtttttee generation. We make the code, data and models publicly available We believe our dataset, models, and insights will catalyze further research in this emerging area.
REFERENCES
Hangbo Bao, Li Dong, Songhao Piao, and Furu Wei. Beit: Bert pre-training of image transformers. arXiv preprint Mxii:22006.0224. 2021.
Jonas Belouadi, Anne Lauscher, and Steffen Eger. Automatikz: Text-guided synthesis of scientific vector graphics with tikz. In The Twelfth International Conference on Learning Representations, 2024a.
Jonas Belouadi, Simone Ponzetto, and Steffen Eger. Detikzify: Synthesizing graphics programs for scientific figures and sketches with tikz. Advances in Neural Information Processing Systems, 37: 85074-85108, 2024b.
Luigi Capogrosso, Federico Girella, Francesco Taioli, Michele Dalla Chiara, Muhammad Aqeel, Franco Fummi, Francesco Setti, and Marco Cristani. Diffusion-based image generation for in- distribution data augmentation in surface defect detection. arXiv preprint arXiv:2406.0053 2024.
Charles Chen, Ruiyi Zhang, Eunyee Koh. Sungchul Kim, Scott Cohen, Tong Yu. Ryan Rossi, and Razvan Bunescu. Figure captioning with reasoning and sequence-level training. arXiv preprint arXiv:/906.0r 02850. 2019.
Christopher Andreas Clark and Santosh Kumar Divvala. Looking beyond text: Extracting figures, tables and captions from computer science papers. In AAAI Workshop: Scholarly Big Data, vol- ume 6, 2015.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929 2020.
Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv e-prints, pp. arXiv-2407, 2024.
Alba Garcia Seco De Herrera, Hemning Müller, and Stefano Bromuri. Overview of the imageclef 2015 medical classification task. In Working Notes of CLEF 2015-Cross Language Evaluation Forum, CEUR, volume 1391. CEUR Workshop Proceedings, 2015.
10

---

Published as a conference paper at ICLR 2026
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog- nition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp- 770-778, 2016.
Ting-Ya Yao Hsu, C Lee Giles, and Ting-Hao' Kenneth' Kenneeh Huang. Scicap: Generating captions for scien- tific figures. arXiv preprint arXiv:21 11244, 2021.
KV Jobin, Ajoy Mondal, and CV Jawahar. Docfigure: A dataset for scientific document figure clas- sification. In 2019 International Conference on Document Analysis and Recognition Workshops (ICDARW), volume 1, pp. 74-79. IEEE, 2019.
Samira Ebrahimi Kahou, Vincent Michalski, Adam Atkinson, Ákos Kådár, Adam Trischler, and Yoshua Bengio. Figureqa: An annotated figure dataset for visual reasoning. arXiv preprint arXiv:1710.07300, 2017.
Zeba Karishma, Shaurya Rohatgi, Kavya Shrinivas Puranik, Jian Wu, and Lee Giles. Acl-fig: A dataset for scientific figure classification. arXiv preprint arXiv:2301.12295 2023.
Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83- 1955.
Xingyu Li, Fei Tao, Wei Ye, Aydin Nassehi, and John W Sutherland. Generative manufacturing systems using diffusion models and chatgpt. arXiv preprint arXiv:2405.00958. 2024.
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. Deepseek-v3 v3 technical report. arXiv preprint arXiv:2412.19437, 2024a.
Luping Liu, Chao Du, Tianyu Pang, Zehan Wang, Chongxuan Li, and Dong Xu. Improving long-text alignment for text-lo-image diffusion models. arXiv preprint arXiv:2410.11817 2024b.
Alex Nichol, Prafulla Dhariwal, Aditya Ramesh, Pranav Shyam, Pamela Mishkin, Bob McGrew, Ilya Sutskever, and Mark Chen. Glide: Towards photorcalistic image generation and editing with text-guided diffusion models. arXiv preprint arXiv:2 2021.
Qwen Qwen Team. Qwen2 technical report. arXiv preprint arXiv:2407.1667) 2024.
Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pp- PmLR, 2021.
Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In International conference on machine learning, pp. 1060-1069. PMLR, 2016.
Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards real-time object detection with region proposal networks. In NeurlPS, 2015.
Juan Rodriguez, David Vazquez, Issam Laradji, Marco Pedersoli, and Pau Rodriguez. Figgen:
Text scientific figure generation. arXiv preprint arXiv:2306.008800 2023a.
Juan A Rodriguez. David Vazquez, Issam Laradji, Marco Pedersoli, and Pau Rodriguez. Ocr-vggan: Taming text-within-iman image generation. In Proceedings of the IEEE/CVF winter conference on applications of computer vision, pp. 3689-3698, 2023b.
Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjöm Ommer. High- resolution image synthesis with latent diffusion models. In Proceedings of the IEEF/CVF confer- ence on computer vision and pattern recognition, pp. 10684-10695, 2022.
Aditi Roy, Ioannis Akrotirianakis, Amar V Kannan, Dmitriy Fradkin, Arquimedes Canedo, Kaushik Koneripalli, and Tugba Kulahcioglu. Diag2graph: Representing deep learning diagrams in search papers as knowledge graphs. In 2020 IEEE International Conference on Image Processing (ICIP), pp. 2585.. IEBE, 2020.
11

---

Published as a conference paper at ICLR 2026
Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily L Denton, Kamyar Ghasemipour, Raphael Gontijo Lopes, Burcu Karagol Ayan, Tim Salimans, et al. Photorealistic text-to-image diffusion models with deep language understanding. Advances in neural informa- lion processing systems, 1436479-36494 2022.
Manolis Savva, Nicholas Kong, Arti Chhajta, Li Fei-Fei, Maneesh Agrawala, and Jeffrey Heer. Revision: Automated classification, analysis and redesign of chart images. In Proceedings of the 24th annual ACM symposium on User interface software and technology, pp. 393 2011.
Shreya Shukla, Nakul Sharma, Manish Gupta, and Anand Mishra. Patentimm: Large multimodal model for generating descriptions for patent figures. arXiv preprint arXiv:2501.15077 2025.
Noah Siegel, Zachary Horvitz, Roie Levin, Santosh Divvala, and Ali Farhadi. Figureseer: Pars- ing result-fiuures in research papers. In Computer Vision-ECCV 2016: 14th European Confer- ence, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part VII 14, pp. Springer, 2016.
Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. arXiv preprint arXiv:2010.02500 2020.
Arash Vahdat and Jan Kautz. Nvae: A deep hierarchical variational autoencoder. Advances in neural information processing systems, 33:19667-19679, 2020.
Jingxuan Wei, Cheng Tan, Qi Chen, Gaowei Wu, Siyuan Li, Zhangyang Gao, Linzhuang Sun, Bihui Yu, and Ruifeng Guo. From words to structured visuals: A benchmark and framework for text- to-diagram generation and editing. arXiv preprint arXiv:2411.11916, 2024.
Jian Wu, Jason Killian, Huaiyu Yang, Kyle Williams. Sagnik Ray Choudhury, Suppawong Tuarob, Cornelia Caragea, and C Lee Giles. Pdfmef: A multi-entity knowledge extraction framework for scholarly documents and semantic search. In Proceedings of the 8th International Conference on Knowledge Capture, pp. 1-8, 2015.
Bin Xiao, Haiping Wu, Weijian Xu, Xiyang Dai, Houdong Hu, Yumao Lu, Michael Zeng, Ce Liu, and Lu Yuan. Florence-2: Advancing unified representation for a variety of vision tasks. In Pro- ceedings of the IEEE/CVE Conference on Computer Vision and Pattern Recognition, pp. 4818- 4829, 2024.
Abhay Zala, Han Lin, Jaemin Cho, and Mohit Bansal. Diagrammergpt: Generating open-domain, open- open-plattonn platform diagrams via Ilm planning. arXiv preprint arXiv:2310.12128,, 2023.
Overview of Appendix Sections
Appendix
A
Training Arch versus no-Arch Classifier Detailed Results
Appendix
for reproducibility
Appendix
Detailed Definitions of Evaluation Metrics
Appendix
Case Studies
Appendix
GPT prompt obtain DOT code representation from architecture figure
Appendix
GPT prompt to get refined image description
Appendix GPT prompt to refine DOT code
Appendix GPT Prompt to convert TikZ code to DOT
Appendix Zero-shot GPT prompt to obtain DOT code from architecture description
Appendix GPT Prompt to Compare Descriptions
Appendix K GPT prompt for TEXT2ARCH task evaluation
Appendix
Few Shot Examples for the Small Language Models based evaluation
Appendix M Detailed Description of Model Architectures
Appendix
Prompts and Results for Lengthened and Shortened Descriptions
Appendix
Human Evaluation
12

---

Published as a conference paper at ICLR 2026
Appendix P Additional Results
Appendix
Frequently Asked Questions
Appendix
Limitations
Appendix
Ethics Considerations and Associated Risks
A TRAINING ARCH VERSUS NO-ARCH CLASSIFIER DETAILED RESULTS
We train multiple models like CLIP (Radford al. 2021). ViT Dosovitskiy et al., 2020). BEiT (Bao et al. 2021). ResNet (He et al. 2016) and report results in Table | We vary learning rate as le-5, 5e-4 and 5e-5. We train for up to 50 epochs and choose the best model based on validation loss. We also perform rotation, horizontal flip and vertical flip data augmentations.
Our best model CLIP trained with a learning rate of 1e-5. It provides after just 2 epochs of training. The precision is 0.83, recall is 0.92 and F1 is 0.87. Inferring this classifier over the entire Paper2Fig dataset gives us set of 80486 architecture images.
accuracy of 83,45%
B PAPER-PARAMETERS FOR REPRODUCIBILITY
All experiments were run machine with NVIDIA V100 GPUs.
For training arch vs no-arch classifiers, we used batch size of 64, learning rate of 5e-5, and AdamW optimizer.
For supervised full finetuning of the TEXT2ARCH models, we trained using A optimizer with batch size of per device, gradient accumulation steps of 4, learning rate of 5e-4, weight decay of 0.001, max gradient norm of 0.3, warmup ratio of 0.03, cosine learning rate scheduler, and 5 epochs with Speed ZeRO3.
For model inferences, we used temperature of 0.7, top-p of 0.9, and max men.length of 1024. For GPT-4o inferences, we used temperature of 05, max tokens of 1000, top p of 0.8, frequency penalty of 1, and presence, penalty of 1.
For evaluation metrics, we used similarity threshold of 0.5 for node matching in graph metrics calculations.
Node matching details: We use SequenceMatcher from difflib for computing string similarity. We perform basic normalization by converting labels to lowercase and removing extra whitespace and newlines. We compute both character-level similarity using SequenceMatcher and a token-level Jaccard similarity, taking the maximum of the two.
are parsed as-is using net- workx.drawing.nn agraph.read dot. Multi-edges and duplicate edges are not explicitly handled or deduplicated. Self-loops are preserved. Rank and positional attributes (e.g.. rank=same, pos, layout hints) are ignored, the evaluation focuses structural and label-based similarity rather than layout fidelity. Edge directionality is preserved. All edge-based metrics (precision, recall, Jaccard) assume directed edges.
DOT parsing/camoniccalzzttn::
Subgraphs
Learning
Epoch
BEIT
1.00-05
33
0.9855
86.2
0,7886
BETT
5.00E-04
19
0,3973
713
0.637
5.00E-05
1,1392
CLIP
1,00E 05
0.3389
87.55
0.8345
CLIP
5.00E-04
36
0.6564
62.9
0.3533
CLIP
5.00E-05
0,3978
83.95
0.7647
ResNet
1.004033
27
0,3944
0,7936
ResNet
5.00F.04
45
1.1516
86.05
0,8036
ResNet
5.00E
0.3774
86.81
0,7966
VIT
5.00E-04
0.5684
77.6
0.6849
VIT
5.005-05
10
0.6373
86.46
0.7787
Table 4: Architecture-image versus No-Architecture-IIme Classification Results
13

---

Published as a conference paper at ICLR 2026
C DETAILED DEFINITIONS OF EVALUATION METRICS
C.I STANDARD NLG METRICS
C.I.1 ROUGE-L
ROUGE-L (Recall-Orienter Understudy for Gisting Evaluation Longest Common Subsequence) measures the similarity based on the length of the longest common subsequence (LCS) between the predicted code Cpred and the reference code Cref- Let LCS(CPrred Cref) be the length of the longest common subsequence. Let m length( (prred) and n length (Cref)
R = I.SS(Crreds Cref)
71
PLes L.C.(C Cret)
m
ROUGE-L (1 B PLCs
PLCs + PLcs
Typically, 3 is set to a large value to emphasize recall, or F-measure is reported where 3
C.1.2 CODEBLEU
CodeBLEU a composite score that evaluates code generation quality by considering n-gram match (BLEU), weighted n-gram match, Abstract Syntax Tree (AST) match, and data-flow match. The final score is a weighted combination of these components.
CodeBLEU = wi BLEU + W2 BLEU weighted
+ MatchAsT w2 Match
where w, are the weights for each component.
C.1.3 EDIT DISTANCE
Edit Distance, specifically Levenshtein distance, is the minimum number of single-character edits (insertions, deletions, or substitutions) required to change the predicted code Cpred into the reference code Cref- It is denoted Lev (Cpreds Cref).
C.1.4 CHRF
chrF (character n-gram F-score) computes the F-score based on overlapping character n-grams be- tween the predicted code Cpred and reference code Cref- It is less sensitive to tokenization issues than bord-based metries. Let chr and chrR,, be the precision and recall for character n-grams of length The chri score is typically weighted average over different n-gram lengths (e.g.. 1 to 6).
C.2 GRAPII-BASED METRICS
These metrics operate on the graph representations Ggt = (Vgt: Egt) (ground truth) and Gpred (Vpred; Epredt (predicted). Node matching performed first. be the set of matched pairs (Ugt, Upred) where Uge E Vgr and Upred E V Vpred, typically found using string similarity of labels and the Hungarian algorithm for optimal assignment above certain similarity threshold T.
C.2.1 NODE PRECISION, RECALL, FI-SCORE
Let N Nmatched = M be the number of matched nodes. Let Ng: = Vgs and Npred = Vpreal- The script 'orig metric catriicccallpppll calculates similarity weighted precision and recall. For match (Uge, Upred) with similarity sim(Ugt, Upred):
Node Precision E(ont Simi(Uges Uprea)
N Npred
14

---

Published as a conference paper at ICLR 2026
Σ Poreeee sim((ygt, Upred)
Node Recall
gt
2 Node Precision Node Recall
Node Fl
Node Precision + Node Recall
C.2.2
NODE PR-AUC
This is the Area Under the Precision- curve, obtained by varying the string similarity threshold for node matching and plotting the resulting (Node Recall, Node Precision) pairs.
C.2.3 EDGE PRECISION, RECALL
Based on the set of matched nodes M. we consider edges. Let Egg matched be the set of edges in Ggt between nodes that have a match in M. Similarly for Pepred An edge (Ugt Vgt) in Ggt is considered correctly predicted if there is corresponding edge (Mpred, Upred) in Gpred where (Ugt, Upred) E M and (Ugt, Upred) E M, Let TPE be the number such correctly predicted edges. Let FPg be the number of edges in Gpred between matched nodes that do not correspond to an edge Gg.. Let FNg be the number edges Ggt between matched nodes that do not have a corresponding edge in Gyred-
TPE Edge Precision = TPE + FPE
TPE
Edge Recall TPs + FNE
C.2.4
EDGE PR-AUC
This is the Area Under the Precision- rrecilionRRecall curve, obtained by varying the string similarity threshold T for node matching and plotting the resulting (Edge Recall, Edge Precision) pairs.
C.2.5 JACCARD SIMILARITY (EDGES)
This considers the of edges present in the adjacency matrices of the matched subgraphs. Let Adj gt be the adjacency matrix for Ggt considering only nodes in Mi (ugel(ugt Upred) E MM, Let
Adjipred be the adjacency matrix for Gpred considering only nodes M2 [Upred (Ugts Upred) E
M}.
Jaccard Index (edges(Adjjn)) n Edges( Adjprea))
EEges U Edges( Adjprea))
This simplifies TPu+FPE+FNe
TPP
D CASE STUDIES
We show 3 case studies comparing outputs from various models for the TEXT2ARCH task in Ta- bles g
Case Study (Table :) The finetuned DeepSeek-7B model significantly outperforms all baselines. including DiagramAgent, GPT, and few-shot prompted DeepSeek variants, in terms of node and edge fidelity. Its output closely mirrors the original diagram, accurately capturing the flow from input signals through synaptic weights, summing junction, activation function, and final output. In contrast, baseline models produce less precise or overly generic representations. This highlights the effectiveness of fine-tuning for structured diagram synthesis and the potential of DeepSeck-7B in tasks requiring high semantic and structural accuracy.
This case study analyzes the performance of various models in generating DOT representations of the TRIM algorithm pipeline, which accelerates image registration through coarse triangulation. The original diagram outlines clear, linear sequence of six modules, each with distinct semantic roles. The finetuned DeepSeck-77 7B model demonstrates perfect structural and semantic fidelity, accurately capturing both the node labels and the directed flow of operations.
Case Study 2 (Table 6):
15

---

Published as a conference paper at ICLR 2026
In contrast, the DiagramAgent baseline introduces incorrect edges and misordered steps, while the few-shot DeepSeek and GPT models show partial correctness but miss key relationships or introduce redundant paths. The ground truth DOT code is incomplete and inconsistent, further emphasizing the superior performance of DeepSeek-7B. This analysis highlights the model's ability to under- stand and reconstruct domain-specifie pipelines with high precision, making it strong candidate for automated diagram synthesis in technical documentation.
Case Study 3 (Table 8): This case study evaluates the ability of different models to reconstruct the architecture of neural network designed for iris recognition, as depicted in the original figure. The network includes a sequence of convolutional and pooling layers, culminating put, with a notable skip connection from the average pooling layer to a later convolutional layer. The finetuned DeepSeek-7B model demonstrates high fidelity to the original structure, accurately capturing both the layer sequence and the skip connection using a dashed edge. In contrast, the Di- agramAgent baseline introduces redundant edges and misrepresents the skip connection, while the few-shot DeepSeek and GPT models show partial correctness but either omit misplace key con- nections. The ground truth DOT code is noisy and inconsistent, further highlighting the clarity and precision of DeepSeek-7BB 7B's output. This analysis reinforces the model's 's strength in understanding and reproducing complex neural architectures with structural and semantic accuracy.
softmax out-
We also show side-by- side-by-side visual diagrams generated by all evaluated models (DiagramAgent GPT, and our few-shot prompting based DeepSeek model) for the three case studies Figs. 5 and respectively. The improvements obtained using model are very clear from these illustrations. Baseline methods lead to several errors like structural mismatches, missing nodes, incorrect edges, and rendering artifacts.
E GPT PROMPT TO OBTAIN DOT CODE REPRESENTATION FROM ARCHITECTURE FIGURE
You expert in analyzing images, doing OCR and extracting structured flowchart information from images. I am trying parse this architecture diagram into text-based graph file. First give OCR output for image. Can you please give me DOT code this image? IMAGE:#ul#
Output all of these in nested XML. OCR output should be within <oer>> </ocr> tags, DOT output should be within <dot>></dot> tags. The ocr and DOT tags should be within "results><<resulll lags.
F
GPT PROMPT TO GET A REFINED IMAGE DESCRIPTION
You are an expert in analyzing research materials, particularly visual content like architecture diagrams. Your task is to examine input image alongside up to descriptive paragraphs and caption that are relevant to the image. These paragraphs may include mix of relevant details and extraneous information about the image.
Your goal is to:
1. Determine if the image is architecture diagram (commonly used in research papers depict the structure, components, or workflows of systems).
it is an architecture diagram, generate a concise, precise, and coherent description 10-20 sentences explaining the main elements of the diagram. Description should include module names, short description of modules, and flow of information across modules.
The description you provide would be further used to train model to generate such architecture images. Hence avoid any irrelevant information in the description.
## Requirements:
1. Carefully analyze the provided paragraphs, focusing on extracting key elements that directly explain the architecture depicted in the image.
16

---

Published as a conference paper at ICLR 2026
Exclude extraneous, redundant, noisy details from the textual content and focus only the architectural
aspects.
Clearly indicate whether the image an architecture diagram or not.
4. Provide your output in a structured format
## Inputs:
IMAGE:
Caption: #caption8
Description: #Descriptionsf
## Example Output:
cresults>
<label>> Jarch not arch] </labe>>>
<newDesc>> Concise and precise description goes here.</newDese>>
</results>
Output results in nested XML. Label output should be within <label></labcl> tags and could be "arch" or "not arch". brief, clear description of the image based on your understanding of the image and provided passages and caption should be within <new Desco </newDesc>>>> tags. The label and newDese tags should within Fresults></resullt tags.
G GPT PROMPT TO REFINE DOT CODE
You expert in analyzing research materials, particularly visual content such architecture diagrams and system diagrams, and code design specialist.
Your task is to:
Analyze both the DOT code and the image identify any incorrect node labels, incorrect connections, incorrect ordering nodes.
Refine the DOT code to ensure it accurately represents the structure and relationships depicted in the image.
Output the corrected DOT file in structured XML format.
## Inputs:
IMAGE:#imageURe
Initial DOT code: (which may contain errors or incomplete data)
#dorCode#t ## Example Output:
<results>
<![CATTI
digraph
0 Node 0 description" ']
[ladel="NNode description" ']
2 [label=' 2 description" "]
[label=" 'Node description"
0-> 1;
0 - 2;
2-> 3;
||> </results>>
## Instructions:
Ensure the refined DOT code fully represents the relationships the image.
2. Maintain proper indentation and formatting in the DOT code.
3. Encapsulate the final DOT code within <results>> < ![[CATAA| []]> </results>>> prevent XMI. parsing
issues.
17

---

Published as a conference paper at ICLR 2026
H GPT PROMPT TO CONVERT TIKZ CODE TO DOT
Given the following LaTeX TikZ code:
First, re-indent the TikZ part for readability.
2. Then, extract all mode text labels and assign each unique integer ID (e.g., 0, 1, 2..).
format: [label="..." "]; to define each node.
4. Infer reasonable directed edges based on layout or label semantics (c.g., data flow, left-to-right, top-to-bottom).
Output the result as DOT file using below graph structure, starting directly with:
<results>>
<![CATA!
digraph
[label=" 0 description" '1
Node I description" "1
2 |label="NNde 2 description" '1
"Noel=="Noee 3 description" "]
0-> I;
0-> 2;
2-> 3;
||> </results>
Do not include any rankdir node settings. Maintain proper indentation and formatting in the DOT code.
Encapsulate the final DOT code within <results>> <![CDATA| ]]> </results>>> to prevent XML parsing issues.
Here is the TikZ code:
#TikZCode#f
1 ZERO-SHOT GPT PROMPT TO OBTAIN DOT CODE FROM ARCHITECTURE DESCRIPTION
You are an expert in analyzing technical descriptions of system architecture, workflows, and process pipelines, and code design specialist skilled in graph visualization using DOT language.
Your task is to:
Read and interpret the following textual description of system, pipeline, or process.
Generate accurate DOT code that reflects the descrihed structure, relationships, and flow.
3. Output the DOT code in structured XML. format for downstream usage.
#l Input:
#Cleaned Deeeeddtiiiiiiininn
## Example Output:
rrsuulss>
[CCAATA
digraph
0 Nldd 0 description" "]
Node description" "]
2 INabel="Nooee 2 description" ]
3 NNode 3 description"
0 -> 1;
0-> 2:
18

---

Published as a conference paper at ICLR 2026
2-> 3:
||>
<hresult>>
Instructions:
Identify all relevant entities (nodes) and their relationships (edges) from the input description.
Use DOT digraph syntax to define the flow structure.
Ensure that node relationships accurately reflect direction and logic described in the text.
Format the DOT code cleanly and consistently with appropriate indentation.
Wraap the DOT code inside CDATA section within XML to avoid escaping issues.
Do not provide explanations or additional commentary; only return the XML block containing the DOT
code.
J GPT PROMPT TO COMPARE DESCRIPTIONS
Your task is to:
1. Analyze the given image along with two candidate textual descriptions (marked as Description and
Description 2).
Determine which description better matches the content and semantics of the image.
Return the index the better matching description (either or 2), followed by a short explanation justifying your choice.
## Inputs:
Image:
IMAG:##mage URL#
Description 1: #dexcription_ _
Description 2: #description
## Output Format:
Output all of these in nested XML.
<rsullss>>
<index>> </index>
<explanation explanation should briefly describe why the selected description matches the image
better.<lexplaaation:
</results>
## Evaluation Criteria:
Accuracy of objects, people, and actions mentioned the description.
Correctness spatial relationships or layout depicted.
Relevance of the description to the overall theme and content of the image.
K GPT PROMPT FOR TEXT2ARCH TASK EVALUATION
You are an expert visual content analysis structured graph representations.
Your task is to evaluate how well generated DOT code matches a given ground-truth DOT code and the corresponding reference image.
## Inputs:
Image:
MAGG::Hmage URL#
Generated DOT code: #Generated-DOre
Ground-truth DOT code: "Ground-TruhhDOTs
## Instructions:
1. Analyze the image to understand the correct structure, node positions, labels, and connections.
Compare the generated DOT code with both the image and the ground-truth DOT code.
19

---

Published as a conference paper at ICLR 2026
Determine if the structure, labels, node ordering, and relationships in the generated DOT code accurately
reflect the image and ground-truth.
Assign a compatibility score between and 5, where:
5 = Perfect match.
Minor discrepancies that don't I affect comprehension.
Some noticeable errors, but mostly accurate.
= Multiple mismatches affect comprehension.
1= Mostly incorrect.
10 Completely unrelated.
Provide concise explanation (2-3 sentences) describing the key issues strengths.
## Output Format:
results>>
<score>><</scor>>
<explanation The generated DOT code correct node labels and most connections, order and direction two edges differ from the image. 3/xpcc//epllaaation
</results>>
Output all of these in nested XML.
L FEW-SHOT PROMPT FOR INSTRUCT MODEL INFERENCE
We use the following few-shot prompt.
You expert in analyzing technical descriptions of system architecture, workflows, and process pipelines, and code design specialist skilled graph visualization using DOT language.
Your task is to convert technical descriptions into DOT graph representations. Follow these guidelines:
Use 'digraph the graph declaration.
Set appropriate rankdir (TB for top-bottom, LR left-right) needed
Use appropriate node shapes (box is default)
4. Create meaningful node labels
Add edge labels where appropriate describe relationships
Keep the graph structure clear and readable
IMPORTANT: Respond with ONLY the DOT code, no explanations or additional text
Here examples of how to convert descriptions DOT graphs: (few (few_shot_eas) swt.ssoeeeeeplss....
Convert the following description into DOT language code. Respond ONLY the DOT code nothing
else: [description)"
Few Shot Examples for the Small Language Models based evaluation
Example Description: A simple web application architecture with frontend that connects to backend API, which then connects to database.
DOT code:
digraph
0 [label=' FFrontend Application') [label='Load Balancer' [Bacen= API Server"]:
[label=" " AAuhenticattion Module") 4 BBsiness Logic Layer"]; 5 [label= Connection
Pool']: ]]; PPrimary Database" "]; 7 "aahell="Cahhht Layer" 8 [label=" Service" "];
0 +
1:
+ 2: 3: 4: 5;
5 + 6: 2 + 7:2
Example Description: microservices architecture where load balancer distributes requests to multiple service instances, each connecting to its own database. The system includes service discovery, API gateway functionality, and inter-service communication through message queues.
20

---

Published as a conference paper at ICLR 2026
Each microservice is containerized and deployed independently with its database schema and business logic.
DOT code:
digraph {
0 [label=" API Gateway" [lahel="Loaal Balancer" "I; " Discovery"I: "I [labcl="User
Service" 4 |labcl=""Orer Service" | 5 PPamel=" Service" 6 [Nobcl="ottffictiioon
Service"]: UUser Database" "I [label=" Database" 9 PPayeenl Database" '];
Messaae Queue" [label= "Cache Layer"]: 12 [label= Monitorin Service"
[label="Config: Service"
0 1: - 2;
4; 5; + 7: 8: 11:5 11: 12, 13;
10; 4 + 10; 10; 10 6; 11;4
Description: A data processing pipeline where data flows from multiple source systems through various processing stages including data validation, transformation, enrichment, and quality checks before being stored in destination data warehouse. The pipeline includes error handling, monitoring, and retry mechanisms for fault tolerance.
Example 3
DOT code:
digraph {
0 [label=""ource System A A"];
]; [Soure= System B"]; 2 "Soucl= System C*
[label="Data Ingestion Layer"]] [label=' Validation Module"":: [label=' Data Transformation
Engine""]: [label= Enrichment Service"";;
clabel=""uultt"" Check Module" ]] [label=' EError Handler"]]: [label="Retryy Mechanism" "]: J; 10 [label=' "Data Warehouse" "]: [label=" MMniiorrn
Dashboard" I|; 12 [labcl="' Log "1 13 |lahc=="Metadatt 'ettddtt Store"
0 + 3;
3; 2 3;
5; 6;
- 10; 8; 5 + 8; 6 8; -
9;
11;7
12; 3 13;
Example Description: message queue system where multiple producers send different types of messages to topic-based queues, and specialized consumers process these messages with dead letter handling, retry logic, and message persistence. The system includes consumer groups for load balancing and message ordering guarantees.
DOT code:
digraph {
0 [label=" PPooduce A"]; Produce B B" PPoduc= C* MMssaa= Broker"
[Topie= 1" 5 |label=' 2" TTppic 3*';
Group I""];
"Consumr Group 2" [labcl=" A"]; 10
B"]]
Ilabel="Consunil "Consumer C"]]; 12 [label=" Letter Queue"') ]]: 13 [label="Retry Handler' 14
[label=' 'Message Store ']: 15 [label=
Service"
1 3; 3; + 4: 5; 6; 7:5
8;
10: 8 11; 12;
12:
14: 15:
Example Description: A comprehensive user authentication and authorization system where users login through multiple interfaces including web, mobile, and API endpoints. The system vali- dates credentials against multiple identity providers, implements multi-facte authentication, gener- ates and manages JWT tokens with refresh capabilities, maintains session state, and provides role- based access control with fine-gre geee-graiedd permissions.
DOT code:
digraph {
0 Wlabel="Webb Interface"]]: [label="Mobile. App"": J: 2 [label=" API Gateway"]: Authee==AAthettcaaaaia Service"]; 4 daahl=="Identiie Provider A"]; [label="Ideniii Provider B"]; 6 [label= Service" [label= "SMS Provider"); 8 [lahel= "adhel='Emall "Email Provider"]; 9 [label=""Toenn Generator" 10
21

---

Published as a conference paper at ICLR 2026
[aabe=""JWT Service"]; 11
Token Store"); [lasei="Session Manager" 13 Aobel="AAthorizattion Service" I| [label="Role Manager" 15 [label=" Permissioo Store" 16
[label=" Database""I 17 [label=" Logger" 18 [label="Rate Rate Limiter")
0 + 3; 1 3; - 3: 4; - 5; - 6; 7; 8; 9; 9 10; 10 - 11; 12; 3 + 13; 13
14: 14 + 15; 3 16; 13 + 16; 17; 18;
M DETAILED DESCRIPTION OF MODEL ARCHITECTURES
3-s-ama-----Inttuueee part of Meta's Llama family open- large language models, trained on mixture of publicly available and licensed data. The "Instruct" variant is fine-tuned with reinforcement learning from human feedback (RLHF) to follow instructions and generate help- ful, safe, and coherent responses. It performs particularly well reasoning, code generation, and instruction-followiin tasks, making it strong choice for structured text-to-code generation scenar- ios.
Qwen2-7B 2een2-BB-nnstruc Instrcctt an instruction-tunel version of Alibaba's Qwen2-7B model, trained on a di- verse multilingual and multi-domain corpus. It is optimized for dialogue and instructionfoolooinng tasks, with strong performance on reasoning and code-related benchmarks. Its relatively small size and efficient architecture make a good fit for tasks requiring both semantic understanding and structured output, especially in snsource-constrainn settings.
7B- 7B-parameter open-source model fine-tuned for conversational and code-related tasks. It is trained on a large-scale dataset with focus on code understanding and generation, and excels producing syntactically correct and semantically meaningful code snippets. Its chat-oriented fine-tuning also makes it robust to ambiguous or under-specified prompts, which is valuable in text-to-code generation where input descriptions can vary clarity.
Beopseck-LLM-7B---e
N PROMPTS AND RESULTS FOR LENGTHENED AND SHORTENED DESCRIPTIONS
To assess robustness, generated lengthened and shortened paraphrased variants of the textual de- scriptions using GPT4o-1 120. In the manual annotations set, the original descriptions contain ~2211 words, while lengthened and shortened paraphrased variants contain 5999 and 113 words respec- tively. Similarly, in the test set, the original descriptions contain ~20 words, while lengthened and shortened paraphrased variants contain ~600 and 113 words respectively.
N.1 GPT40-1 120 PROMPT FOR LENGTHENED DESCRIPTIONS
You will be given short, cleaned description of image. Your task is significantly increase the length of the description while preserving #exactly= the same information content. Do add any new details, facts, interpretations, architectural components, domain-specific terms, or any information not explicitly stated in the original description.
You must only:
Rephrase, elaborate, and expand the phrasing what already present.
Use more descriptive language, redundant clarification, or extended explanations.
Maintain the original meaning strictly.
Avoid introducing any task-relatee details, instructions, references datasets, DOT code, models, any processes outside of the original text.
The output should be verbose, highly expanded paraphrase that conveys the same information with no new content.
INPUT: #CLEANED DESCRIPTION
OUTPUT:
significantly longer version that preserves all original meaning and adds information.
22

---

Published as a conference paper at ICLR 2026
N.2 GPT4o-1 120 PROMPT FOR SHORTENED DESCRIPTIONS
You will be given cleaned description of image. Your task shorten the description while preserving *all* the information contained the original text. You must not remove any factual content, omit steps, or lose meaning.
You must only:
Compress, condense, and streamline language.
Merge sentences where possible without losing information.
Remove redundant phrasing but keep all details present in the original.
Avoid introducing any new content changing meaning.
Do not mention any task lask-specific details, DOT code, metadata, anything outside the given description.
The output should be shorter, more concise paraphrase that preserves every piece of original information.
INPUT:
#CLEANED DESCRIPTION HERE#
OUTPUT:
shorter version that conveys all original content with no loss of meaning and no new additions.
N.3 RESULTS
The results are summarized the TEXT2ARCH manual annotation set and test set respectively. As expected, significant length shifts degrade performance, but the trends are consistent and provide valuable insights into the sensitivity of text-to-structure generation.
our best model (finetuned DeepScck-7BB for the
O HUMAN EVALUATION
For training Arch versus no-Arch classifier, we performed human labeling. Training data was filtered by annotators with deep domain knowledge (the authors), and the task is highly objective. For the manually annotated evaluation subset, the annotators labeled node and edge sets with very high consistency: 98 percent agreement for nodes and 96 percent for edges. Due to the cost of expert annotation, we did perform overlapping annotation for the entire dataset, but the agreement numbers above reflect strong reliability.
We acknowledge the importance of human evaluation of end end system. Hence, we con- ducted human preference study to assess diagram quality. Across paired comparisons, our model preferred 71.6% of the cases while DiagramAgent is preferred in 28 8..4.. This provides clear evidence that human evaluators perceive the outputs of our system more semantically correct and structurally coherent.
P ADDITIONAL RESULTS
P.1 COMPARISON WITH AUTOMATIKZ
The results in Tables and show that the proposed Text2Arch model performs much better than Automatikz on both the manual annotation set as well as the test set.
P.2 COMPILATION SUCCESS RATE
Compilation success is crucial for the practical utility of DOT-based generation systems. We com- puted compilation rates across all fine-tuned models. Interestingly, Ilama3 (40.03%) leads to much lower compilation rates compared to Qwen2 (95.67%) and DeepSeck models (93.44%). Our analy- sis shows that truncated output is the major problem.
23

---

Published as a conference paper at ICLR 2026
P.3 VARYING HUNGARIAN ALGORITHM THRESHOLD (T)
String similarity matching may under- or over- werr-mathh aliases. The purpose of the Hungarian match- ing with threshold 0.5 is limited to aligning lexical node labels during metric calculation.
In this section, we present full results across multiple thresholds (T E 0. 0.3, 0.5, 0.7, 0.9), demon- strating monotonic behavior and showing that model rankings remain stable in Table
Q FREQUENTLY ASKED QUESTIONS
Q.1 DEFINITION OF "SCIENTIFIC ARCHITECTURE"
We the term "scientific architecture diagrams" to refer to structured graphical representations of computational or experimental workflows, methodological pipelines, and scientific system designs commonly found in scientific and engineering publications.
Q.2 FOR THE SAME DIAGRAM, ONLY ONE CORRECT DOT EXISTS?
single diagram can indeed correspond to multiple syntactically different DOT files due to vari- ations in node ordering, edge ordering, and layout directives. To provide unique training target and ensure valid comparisons, we canonicalize all DOT graphs prior to use. Specifically, we: (i) sort nodes lexicographically by label, (ii) sort edges by target index pairs, (iii) remove layout or stylistic attributes that do not affect topology.
Following the canonicalization procedure, each diagram is mapped single DOT representation that uniquely captures its structure. This ensures consistent supervision and unambiguous evaluation, while remaining correct up to graph isomorphism. The evaluation metrics are therefore insensitive to semantically irrelevant syntactic variations.
During evaluation, we compute structural equivalence by converting DOT graphs into adjacency matrices and performing graph isomorphism checks. Two diagrams are considered equivalent their node labels and directed edges correspond under a bijection. All reported graph-level metrics operate strictly on node content and edge connectivity and are invariant to layout differences.
This approach is consistent with evaluation strategies used in other and additionally, our text based evaluations align with the evaluations adopted by DiagramA- gent (Wei et al. 2024), which we use as a baseline.
domains
Q.3
WHY WAS GPT5 NOT USED?
GPT-5 released just before the ICLR submission deadline. GPT-5.1 was also released post- deadline. For fairness and compliance, we included models readily available before the submission deadline.
Q.4 DID YOU DE-DUPLICATE NEAR-IDENTICAL FIGURES/DESCRIPTION ACROSS SPLITS?
We designed the dataset split to random, ensuring no intentional overlap. Also, note that our dataset contains data from real papers hosted arxiv. Unlike web collections where there could be duplicates, typically it is not expected that figures would repeat across different papers on arxiv.
R LIMITATIONS
While our work makes significant strides, it has several limitations. First, our dataset and experi- ments are limited to English-languag descriptions, and extending multilingual settings remains unexplored. Second, we did not experiment with advanced alignment techniques such as Direct Pref- erence Optimization (DPO) Reinforcement Learning with Human Feedback (RLHF), which could further improve human- perceived quality. Third, our models are trained and evaluated on clean, well- aligned data; their robustness to noisy ambiguous real-world inputs yet be assessed. Fourth,
24

---

Published as a conference paper at ICLR 2026
while focused on DOT code as the intermediate representation, exploring alternative graph de- scription languages or direct image generation remains an open direction.
Additionally, in complex cases, trained models unable to generate architecture dia- grams with dense connections, multiple self-loops. Further, the DOT code generation pipeline relies heavily GPT-4o and rule-based post-processing, which may introduce inconsistencies propa- gate errors from OCR and object detection stages, especially in complex or low-quality diagrams. DOT2 edge direction relies on arrowhead heuristics; failure modes although not commonly observed (overlapping arrows, ambiguous heads, dashed lines) can occur in some cases. While we categorize diagrams into easy, medium, and hard based on node count, this does not always reflect true semantic or structural complexity.
Multi-edges and duplicate edges are not explicitly handled or deduplicated.
Addressing these limitations can further enhance the applicability and generalization of text-to- architecture systems.
ETHICS CONSIDERATIONS AND ASSOCIATED RISKS
While our work advances the state text-to-aree to-rriitteeeee diagram generation, it important ac- knowledge potential ethical implications and risks. First, our dataset and models are trained exclu- sively on
data, which may limit accessibility and fairness for non-English speakers and perpetuate linguistic biases. Second, the models may inadvertently encode and amplify biases present in the training data, such as over-representing certain architectural patterns or terminology, which could lead to homogenized culturally skewed outputs. Third, the generated diagrams, while structurally faithful, are not guaranteed to be semantically correct all contexts, and over-reliance automated outputs without human verification could result in misleading erroneous designs. Additionally, the models are not explicitly aligned with human preferences through techniques like DPO RLHF, which may limit their alignment with user intent in ambiguous cases. Finally, as with any generative system, there is risk of misuse, such as generating plausible-looking but incor- rect diagrams for critical systems, which could have downstream safety or security implications. We recommend that users treat the outputs as assistive rather than authoritative and incorporate human oversight in high-stakes scenarios.
25

---

Published as a conference paper at ICLR 2026
Fig obtained using generated DOT code by our TEXYZARCH'S finetuned DeepSeck 7B model
Original ligure (Fig. from htwp:///ggs///aaaa...o/////////0
Activation function
Input
Output
Signals
Summing
junction
X
OL
Synaptic weights
(b) Figure description: The umage is an archutecture diagram of pereeptron, a fundamental unit in neural networks. The perceptron archi- consists several key components: Iaput Signals x2, ... These inputs perceptron, represented
x2, .. xl. 2. Synaptic Weights (w], w2, wly: Each imput signal is associate with synupic weight (wl. w2, wI) that scales the inpui signal. Summing Junction (E): weighted inpats are summed together
summing junction, represented by symbol this summing junction is denoted u. Activation Function (b) The summed value then passed through activation function, denoted as d(.). This function determines the output of the perceptron. Output (y): The final output the perceptron represented as y. which the result the activation function applied
outpot
summed inpul. The flow of information in the perceptron slarts with the inpul signals being multiplied by their respective synaptic weights. These weighted inputs are then summed at the summing junction. The resulting sum is passed lunction produce (inal outpul. Generated DOT Code from liuetuned DeepSeck-7B:
through
digraph|
x1 [label="s "x1"'"1"""" 1;
"I; x2 [label= "xpell='x22""" "x2"|; [lahel="'x"") [lahel=""w!") w2 [label=' wl "I "oobel="wl'">>
[label="
sigma [label="X""] [label="u "ubell""""] 1 phi [lahel="<(()")) y [label="y"I:
x1 + wl; x2 w2; xl wl; w1 > sigma; w2 sigma; wI + sigma; sigma + u; - phi; phi
from DingramAgent Baseline:
digraph {
0 [label="Input Signals"]]: ": [label="Inptl] Signals ) [label="Input Signals" 3 [label="Input
Signals"J]: :: [lapel="Iaput Signals"]]: [label="Input Signals""]: 6 [label="Inpu Signals"
[label=""Input Signals""]: 8 [label="'Inpu Signals""]: [labcl=""Iput Signals""l: 10 [labcl="Inppr
Signals""]: 11 [label="'nnut Signals" 12 |label="Inpuut Signals"' |label=" Signals" 14
Ilabel="Input Signals""I; 15 [label=" "Input Signals""]: 16 |label=""Inuut Signals""1: [labcl="
Signals"]]; 18 [lapel="Input Signals "}: 19 [label="Input Signals" ']: 20 [label="Input Signals"
"Syapti"Synppiic weights"]]: 22 "label="Synappii
weights"|] 23 [label="" weights" '];
"Synati" weights" 25 [label=""Syappt"" weights" 26 [label=" junction 27
function' J: 28 [label="']] "] 29 [label=""]]
20
21; 19 + 22; 18 23; 17 24; 16 25; 21 + 26; 22 + 26; 23 26; 26; 25 + 26; 26
28; 28 27: 27 - 29;
(c) Generated DOT code from few-shot prompting of instruction-tuned DeepSeek Model: digraph node [shape=""ox"":
0 Mlabe=="Input Signals"]; "Activatton Function" [label="Output" 'J: 2: 3;
Weights"]]: "label="Summinne Junction' "1;
(1) Generated DOT Code From GPT:
digraph {
[label=" x1, x2, .... ]I'":: [label=" Weights wl, w2. wI']: WWeihhed
Inputs wi)"]: J; 3 "
Summing Junction (I3""]: [label= u'']: "abel="Activvttoon
Function (Iu)"'; [label= "Output y" 1; 2; + 3; 3 + 4; +
Ground Truth DOT code:
digraph [
[label= (DO. "I: [label= [label= "woeel==w"""" "w"": ];:4]
[label="ww 1"]; [label=""u"]] [label= mmmi
n 1g"1:->4:00 8: -> 4 1:3
Figure 4: Case Study 1: Comparison showing DeepSeek-7B inference significantly outperforming all baseline methods. DeepSeek achieved superior performance across all key metrics (node_f1, edge_fl, node accuracy) compared to diagramAgent, GPT, and DeepSeck-chai baselines.
26

---

Published as a conference paper at ICLR 2026
weights
Signais
Senaptic weighta
Ioput Sigsaio
Sgnaptic weiglts
Summing junctor
Activation Dunction
Input Signaos
Senpptic weights
Ipeat
Signale
wnightx
Weighted
Input Sigzala
Danmaby juscioa (ngiggraag""
Input Signalo
Ingurt Signaii
Imput Signala
Ourgity
Inpu: Signals
Siguais
Synaptic Weights
Ingur Signalo
Input Signaus
Summing Junction
Activation Function
Inpur Signsio
Inpui Siguaco
Output
Input Signals
Input Signaia
Figure 5: Illustrations for generated dots using DiagramAgent (left), GPT (right top) and fewShot DeepSeek (right bottom) corresponding to Case Study I shown in Fig.
27

---

Published as a conference paper at ICLR 2026
Original hgurr (Fig. 1
From https//aakkkv..rrp///////// http://ww...app/////000.0001000.
Fig obtained using generated DOT code by our TENTZARCH's finetuned DeepSeck 7B: model
Subsampling
Unsharp masking
Sagmantation
extraction
Suzsampling
Unsharp masking
Segmentation
Adding
Delaunay trtangulation
Delounay triangulation
Adding extra feature points
Sparse feature Pntraction
Figure deseription: image architecture diagram depicting pipeline propesed TRIM algoritim accelerating image registration via coarse triangulation. The pipeline comsists of six main modules: 1. Subsampling: This initial step reduces the resolution of impat image decrease computational complexity. Unsharp Masking: This module enhances edges
subsampled image improve the accuncc of suhsequent segmentation. 3. Segmentation: The enhanced image segmented into distinct regions to facilitate feature extraction. Sparse Feature Extraction: Key features are extracted from the segmented image, focusing on sparse significant points. Adding Extra Feature Points: Additional feature points incorporated ensure robust triangulation. Delsunay Triangulatios: The final step applies Delaunay triangulation to the feature points, creating a coarse triangulated represeniation of imuge. The llow of information follows lincar path subsampling unsharp masking. then segmentation. segmentation, sparse feature extraction is performed. followed by the addition of extra feature points, and linally, Delaunay triangulation applied. Generated Code from Biutuundd DeepSeck-7B.
digraph {
[label=" "Subsampling"", "] 1 [lahel=" masking" "]; 2 [label=" "label=""Segmentarrii "Segmentation" "I; Tlael=="Sparse feature extraction "]; Maabel="AAdingg extra feature points"| ";; 5 4;
triangulation" "];
1;
(d) Generated DOT code from DingramAgent Baseline:
digraph {
"Suboll="SSbbanninggg... [label=" triangulation ]]: [label="Unnhhrrp masking" [label=" " 'ddiin extra feature points" 4 "aabel=="Semmetattinnn "]; ); [label="Sparss) feature extraction" '1;
+ 2; 1; + 4 5;3 4;
Generated Code
digraph {
[label=" "Subsampling"1 J; [label=" Masking" 2 [ "Segmentation"") 3 [label=""pparse
Feature Extraction" "]; Mabbel="Adding Extra Feature Points" "]: [label=" Triangulation' "]; 4;
1:
(1) Generated DOT code from few-shot prompting of instruction- tuned DeepSeek Model:
digraph {
[label=" "aaboll="Suubannnn "Subsampling""; [label="Unshary Masking"]]: | "Segmentation"): [label=""Sparse
Feature Extraction" "]: "aabell"Addiing Extra Feature Points" Mabbel="Delaune Triangulation" "];
1:0 + 2; 3;
5;
(g) Truth DOT code:
digraph
[label= "Segmentation"I]
triangulation" "]: Mtabel="Unshant masking" 3 [label=" "uals=="c/s>SSuaamplnng "]; "albel="Spprree feature extraction") "]; 5 "label="AAddii extra feature
points" "]:
0 4:4
5:5
0:
Figure 6: Case Study Comparison showing DeepSeek-7B inference significantly outperforming all baseline methods. DeepSeek successfully generated DOT code that exactly matches the ground truth structure while other baselines show varying degrees performance.
28

---

Published as a conference paper at ICLR 2026
Subsampling
Jacharp Macking
Segmentation
hii Teles
Sparse Feature Extraction
Space fnlerniiaels
Adding
Delaunay Triangelation
Figure 7: Illustrations for generated dots using DiagramAgent (left), GPT (middle) and ShoS DeepSeek (right) corresponding to Case Study 2 shown in Fig. 6
29

---

Published as a conference paper at ICLR 2026
(a) Original ligure (Fig. 16 from
httpss//aaaivv.orr/uuuuu wtwp::/wwwrppplpp///ocoo// 09488v]
Core
Carw
Fig obtained using generated by TEXT2ARCH's DeepSeek
35
Post
COP
Figure description: image architecture diagram depicting a neural network designed recegnition. archilecture consists of several sequential modules: Input: The initial input layer that rescives the raw data. 2. Conv 3x5; convolutional layer with 3x5 filter size, which extracts features from input data. 3. Pool avg: An average pooling layer that reduces spatial dimensions
feature maps. with 3x3 filter size, further relining Jeatures. Conv 3x5: second convolutional layer with 3x5 filler size, continuing the feature extraction process. 6. Pool max: max pooling layer that further reduces the spalial dimensions by taking providing the Softmax: The output layer that applies the soltmax function to produce the final classification probubilities The flow of information starts from input layer, passes through
4. Conv 3x3: Another convolational
value
region.
convolutional layer with
feature maps.
and panling layers sequentially, and from the average pooling layer the second convolutional layer, indicating shortout in the network to improve learning efficiency. (c) Generated DOT Code from fineluned DeepSeek.7B:
softmax layer. There
skip
digraph {
[label=" "Input" [lahel="'Cone
5" 2 [label=' "Pool avg" "]: [label="Conv 3"1; [label=' "(ol="""oor CCon 3 5" " max "]: 6 [label=' 3 3"";: [label=" 4; 5; 6:
1: 2
[style=dashed]:
(d) Generated DOT code from Diagram.Aeen Baseline: digraph
|label= "Inpu"" [label=" 3 5"" [label=' "Pocl="PPoolo avg"l: 3 [label=" 3 3"1; Ilabel= "Cony 3 x [labcl= max "1 6 "Cone 3 x 311; Mabbel="Softtaxs
+ 1; + 2:
6; 7;2 3;
Generated
few-shot prompting Instruction-tuned DeepSeck Model:
digraph {
node [shape=" "oooppe="box"]]" "bxx"" (laael="Inpuu" [label="Conv 3x5"); llabel="Pool avg"): 3 [label="Conv
3x3" |: label="Conv 3x5"]: [label=' max" 6 Hlabel="Conv 3x3"); "aaell=SSootay "]; 1:0 2:
4; 4 5; + 6; scaae=""ellipsc" label=" "Skip connection"
(t) Generated DOT Code from GPT: digraph
|label=' "Inpt""I [label="Conv "; [label=" avg");: [label=' 3x3")]; [label="Conv
3x5 (second)')) 'I; 5 [label="PPol) max"]: 6 [label="Come 3x3 (final)" "Sbel=""Sfftmx")]
1:1 > 4; 5; 6; 7; 4; skip connection
Ground Truth DOT code: digraph
[label= "Conv 3x3"|: 1 [label= 3 3"]; [lahel="'Pod 3 [label="Conv 5"]; [label=" "Pool avg""]; [label=" x5"";; 6 "Softmax"" [label="Input");
4 + 1:0
6: 5: 0, 3 4: + 2: +
Figure 8: Case Study 3: Comparison showing DeepSeek-7B inference significantly outperforming all baseline methods, successfully generated DOT code that exactly matches the ground truth struc- ture while other baselines show varying degrees of performance.
30

---

Published as a conference paper at ICLR 2026
Input
Input
Canv 3 x
Canw 3x.5
Input
Conv 3x3
Softmax
avg
Pool avg
Conv 3 3
Conv 3x3
Conv 3x5
Pool avg
Conv 3x5
Conv 3 5
(second)
Pool max
max
Pool max
Conv 3x3
Skip connection
Conv 3x3 (final)
Conv 3 x 3
Softmax
Softmax
Figure 9: Illustrations for generated dots using DiagramAgent (left), GPT (middle) and fewShot
DeepSeek (right) corresponding to Case Study 3 shown in Fig.
Text Metries
Graph Metrics
ROUGE-L
CodeBLEU
Dis-
Node Recall
Node
Edge
Edge
Edge
Edge PR-AUC
Jaccard
lance
Prec
F1
PR-AUC
Prec
Recall
F1
Sim.
Lengthened Dese 44.7
682
48.7
72.8
62.7
66.4
23.8
52.3
33.0
40.2
25.1
31.2
Shortened Desc 55.
50.0
491
65.0
70.6
75.5
71.4
19.8
61.9
45.3
50.7
34.0
39.6
OOiginal Desc. 55.2
49.3
1407
66.6
66.1
78.1
69.4
1774
39.4
44.6
49.1
35.1
39.8
Table 5: Description length variation results on TEXT2ARCH manual annotation set.
Text Metrics
Graph Metrics
ROUGE-L
CodeBLEU
Edit Dis-
chrF
Node Prec
Node
Node
Node PR-AUC
Edge
Edge Recall
Edgo
Edge
Jaccard
fance
Recall
F1
Prec
Fl
PR-AUC
Sim.
Lengthened Dese 32.2
28.3
793
32.3
30.6
25.4
26,3
1044
16.9
9.2
11.1
10.0
8.0
Shortened Desc
33.7
25.3
Oriinaa Desc.
46.8
34.5
608
55.7
66.2
69.6
65.7
21.5
46.4
34.2
38.0
23.7
28.6
Table 6: Description length variation results on TEXT2ARCH test set.
Text Metrics
Graph Merrics
LOUGE-L
Edit Dis:
chrl
Node
Node Rocall
Nade
Node PR-AUC
Edge
Eulge
Edge
Edge PR-AUC
Jaccard
Pree
Recall
Automatikz
41.
531
41.2
46.9
3699
38.7
12.3
19.1
8.6
10.9
8.9
7.2
Tex12Arch (fine
55.2
407
66.6
66.1
78.1
69.4
27.4
59.4
44.6
49.1
35.1
39.8
tuned
DeepSeck-
7B)
Table 7: Results on TEXT2ARCH manual annotation set.
Text Metries
Graph Metrics
ROUGE-I
Fdit Dis.
chrf
Node Prec
Node
Node
Node PR-AUC
Edge
Fddge
|idge
Edge PR-AUC
Jaccard Sim.
lance
Recall
FI
Prec
Recall
Automatikz
37.9
37.0
42.1
33.6
34.3
T1.3
20.4
8.4
8.1
7.2
Tex12Arch (fne-
46.8
608
55.7
66.2
69.6
68.7
21.5
46.4
34.2
38
23.7
28.6
tuned 7B)
SeekSock-
Table 8: Results on TEXT2ARCH test set.
31

---

Published as a conference paper at ICLR 2026
Model
Node Pree Node
PR-AUC Edge Pree
Edge
Edge
Edge PR-AUC
Llama 3-88 (r=0.1)
31.2
49.1
35.2
6.9
23.2
15
17.5
8.7
Llama-3-8B (7=0.3)
44.2
Llama-3-88 (7=0.5)
22.7
35.8
25.5
6.9
20.2
6.1
8,7
8.7
5.5
Llama-3-8B (7=0.7)
19.1
30.4
21.3
6.9
17.6
4.6
6.7
8.7
4.2
Llama-3-88 (7=0.9)
15.7
Qwen2 7B (7=0.1)
35.8
52.9
39.2
7.9
20.4
13.4
15.5
8.1
Qwen2-7B (r=0.3)
33
48.7
36.1
7.9
20.7
10.1
12.8
8.1
8.2
Qwen2-7B (r=0.5)
41.7
7.9
21.4
7.5
10.4
8.1
Qwen2-7B
25.1
36.8
27.4
7.9
20.2
6.2
8.1
Qwen2.78 (ra0.9)
15.1
21.6
16.4
7.9
13.1
3.3
4.8
8.1
DeepSeck ()=0.1)
67.3
69.9
66.3
20.8
34.3
22.5
DeepSeek (7=0.3)
32.6
DeepSeck-7B 7B (7=0.5)
62.8
65.2
61.8
20.8
47.4
30.6
35.3
22.5
26.3
DeepSock-7B (r=0.7)
60
62.3
39
20.8
41.4
28.3
33.3
22.3
24.7
DeepScek.7B (7=0.9)
22.5
Table 9: Graph Metrics with Varying Hungarian Algorithm Threshold
32


Reviews:
[{"review_id": "H22Gmry7Gt", "reviewer": "Reviewer_pUFM", "summary": "The paper introduces a dataset for training models to automatically convert natural-language descriptions into scientific architecture diagrams. The authors report that a compact model trained on the proposed data outperforms larger models (e.g., GPT-4o) on the benchmark tasks defined in the paper.", "questions": "1. Definition and coverage of “scientific architecture.”\n2. How were the 99 images in Fig. 3 selected, and how does their complexity compare with the full dataset?\n3. Is the target \\texttt{DOT} constrained by a formal grammar during training/inference?\n4. How robust is the model to paraphrase, long/underspecified descriptions, or OOD domains?", "limitations": "", "rating": null, "confidence": 4, "soundness": 2, "presentation": 1, "contribution": 2, "strengths": "1. Framing NL to diagram generation for scientific architectures is a well-scoped and timely problem with practical value for documentation and education.\n2. The paper provides a purpose-built dataset aligned with the task, which can catalyze further research and standardized evaluation.\n3. Initial experiments indicate that a smaller, task-specialized model can surpass much larger general-purpose models, suggesting meaningful gains from domain-specific supervision.", "weaknesses": "1. The paper’s core innovations and their separation from prior art are not sufficiently explicit. \n2. The definition of scientific architecture, the selection of the 99 images in Fig. 3, and the complexity distribution of diagrams across the full dataset are unclear.\n3. It is unclear whether a diagram has a single “correct” \\texttt{DOT} representation, and how correctness is measured when multiple valid encodings exist. \n4. For the same digram, only one correct DOT exist? If not, how they meature the correctness?\n5. If many diagrams resemble the simple patterns in Fig. 1, current VLMs may already perform well.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "RdBDI9weG7", "reviewer": "Reviewer_4mvK", "summary": "This paper presents a dataset for diagram generation, based on descriptions. The paper provides a dataset involving the DOT language. It then continues to explore closed-source models such as GPT4o and fine-tuned models, leveraging automatic metrics for evaluation.", "questions": "l. 126: I don't understand the argument why you don't want to evaluate the image: comparing the ground-truth image to the generated image is very important from a user perspective\n\n- Why did you exclude GPT5?\n\n- In l.203ff: you do some human filter - where are the agreements? How reliable are the humans involved?\n\n- l.310: so, few-shot prompting is meaingless?\n\n- l.322ff: But SFT mostly leverages training on the training dataset, right?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "- a new dataset\n\n- insights on the performance of different models, e.g. fine-tuning helps\n\n- discussion of a relevant new problem, even though there are already some existing works on similar tasks", "weaknesses": "- There is no human evaluation at all\n\n- While competitor approaches such as Automatikz are mentioned, there is no comparison\n\n- Some competitor models are missing, e.g. TikZero\n\n- Arguably, just fine-tuning a model on the dataset could be considered a bit incremental in contribution\n\n- I feel more sophisticated automatic metrics such as the ones proposed in TikZero or Automatikz should be explored\n\nTikZero: https://iccv.thecvf.com/virtual/2025/poster/51", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "Y8nYB6EPXw", "reviewer": "Reviewer_uvQ1", "summary": "**TEXT2ARCH** introduces a 75K+ text–DOT–image dataset that fills a clear gap for text-to-architecture generation, compares **DOT1/2/3** variants, and adds **novel graph-level metrics**; fine-tuned 7B–8B models (notably DeepSeek-7B) beat DiagramAgent and few-shot baselines.", "questions": "See weaknesses; I’m open to revising the score if the rebuttal provides sufficient evidence.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 3, "strengths": "1. **TEXT2ARCH fills a clear data gap.** The dataset addresses a previously missing resource for text-to-architecture diagram generation with aligned text–code–image triplets.\n2. **Comprehensive comparison of DOT variants.** Evaluating DOT1/DOT2/DOT3 provides a thorough view of how different curation/refinement stages affect quality.\n3. **Novel, task-appropriate metrics.** The graph-level evaluation (node/edge F1, PR-AUC, Jaccard) is thoughtful and well-aligned with the problem’s structural nature.", "weaknesses": "1. **Compilation success rate is unreported.** The paper does not quantify the percentage of generated DOT that compiles successfully, which is critical for practical usability.\n2. **Limited qualitative evidence.** Case studies mostly show prompts and code; they lack rich visual side-by-side outputs and analyses of both good and bad generations across compared methods. It would be stronger to show the rendered diagrams and juxtapose multiple model outputs with brief error analyses.\n3. **Insufficient SFT details (around line 322).** SFT setup is under-specified, only the prompt is given. Training loss/objectives should be described to ensure reproducibility.\n4. **Missing TikZ results despite related discussion.** While focusing on DOT is reasonable, the paper cites TikZ-based prior work; a small TikZ transfer study (even limited) would help position the approach and set expectations for broader applicability.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "CiWs9QxZLV", "reviewer": "Reviewer_yJFJ", "summary": "The paper introduces TEXT2ARCH, a new task and large-scale dataset (75,127 text–DOT–image triplets; 60,519/7,565/7,043 split) for generating scientific architecture diagrams from natural-language descriptions via intermediate DOT code. The dataset is curated through a three-stage pipeline—(1) filtering architecture figures, (2) DOT extraction with OCR/object detection + GPT refinement (DOT1→DOT2→DOT3), and (3) description refinement—illustrated in Fig. 2, with distributions and statistics in Fig. 3. The authors propose graph-level metrics (node/edge precision/recall/F1, PR-AUC, Jaccard) in addition to NLG metrics.", "questions": "- Beyond Table 3, can you expand the human-labeled set (≥500) and report the same metrics to better calibrate DOT3 quality?\n- Provide TikZ-native evaluation for DiagramAgent (and a DOT-native variant for your model) to avoid cross-format conversion via GPT.\n- Did you de-duplicate near-identical figures/descriptions across splits? Please report a hash/similarity analysis.\n- Show results across node-match thresholds and with alternative label normalization; report effects of handling multi-edges/duplicates.\n- Quantify contributions of each curation stage (classifier, OCR/detection, GPT refinements) to final performance; show training with DOT1-only/DOT2-only.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- Scoped, high-impact dataset for architecture diagrams with aligned text–code–image triplets and complexity bucketing; useful beyond the paper’s models.\n- Clear curation pipeline (classifier + OCR/detection + GPT refinement) with ablations across DOT variants (DOT3≫DOT1/DOT2).\n- Consistent empirical gains from finetuning small models (DeepSeek‑7B best on both automatic and GPT-based judging).", "weaknesses": "- Baseline fairness: DiagramAgent (TikZ) → DOT via GPT may degrade/alter structure; results could change with a native TikZ-based evaluation.\n- Label/eval circularity risk: GPT‑4o is used to generate/refine DOT labels (DOT1→DOT3) and to score outputs; this can bias comparisons and makes “ground truth” partly model-dependent. The human set (n=99) helps but is small.\n- string-similarity matching (Hungarian with τ=0.5) ignores diagram layout and may over/under-match aliases; multi-edges and duplicates aren’t handled; layout attributes are ignored.\n- no analysis of near-duplicate figures across splits or of overlap between description sources and DOT generation that could inflate performance.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)