Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

SketchAgent: Generating Structured Diagrams from Hand-Drawn Sketches

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims that a multi-agent pipeline—a sketch-to-code model, an editing model, and a compiler-backed verifier—can turn hand-drawn sketches into structured, machine-readable diagrams, reporting a Pass@1 of 82.34 on its new…

desk verdict New diagram-inversion benchmark and pipeline, but the 'hand-drawn' claim is untested because the inputs are deterministic degradations of compiled LaTeX diagrams. read the letter →

arxiv 2508.01237 v1 pith:YU6BYHSH submitted 2025-08-02 cs.AI

Cheng Tan , Qi Chen , Jingxuan Wei , Gaowei Wu , Zhangyang Gao , Siyuan Li , Bihui Yu , Ruifeng Guo
show 1 more author
Stan Z. Li
This is my paper · ORCID
classification cs.AI
keywords sketch-to-diagramgenerationmulti-agentsystemstructureddiagramTikZcodevision-languagemodelseditingSketch2Diagrambenchmarkcompile-validateloop
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper proposes a new task, sketch-to-diagram generation, and a multi-agent system called SketchAgent that turns a sketch image plus a user query into executable diagram code (TikZ/LaTeX). The central claim is that this conversion, previously manual, can be automated by splitting it into sketch recognition, code generation, and iterative validation. On the paper's own Sketch2Diagram benchmark, SketchAgent reports a Pass@1 of 82.34 for sketch-to-code generation and 93.12 for diagram editing, ahead of several open- and closed-source vision-language and code models. The paper also contributes a benchmark of more than 6,000 sketch-code pairs spanning eight diagram categories. If the claim holds, sketching becomes a fast front end for producing editable, machine-readable diagrams.

What carries the argument

The load-bearing machinery is the compile–validate loop around a symbolic code representation. Each sketch is first expressed as a token sequence in TikZ/LaTeX, the structured language of the target diagram; that code is then compiled to an image so the system can compare it back against the input sketch and the user's instructions. The Check Agent acts as the loop's gate: it verifies syntax and executability, and when compilation succeeds it uses GPT-4o as a visual judge to decide whether the rendered diagram matches the sketch, triggering regeneration by the appropriate agent otherwise. This lets the pipeline convert ambiguous pixel input into structurally constrained, machine-readable output.

What would settle it

Collect a test set of genuine freehand sketches, drawn by humans on paper or a tablet with possibly incomplete or messy strokes, for the same diagram types and measure SketchAgent's Pass@1 and edit success against the benchmark results. If Pass@1 falls far below 82.34, or if human judges cannot tell which rendering matches the sketcher's intent, the central claim of automating hand-drawn sketch conversion is not supported for real use.

Watch

Extended reading notes

Core claim

SketchAgent's core discovery is that a structured code representation is the right intermediate for sketch-to-diagram: instead of generating pixels, the system generates diagram code tokens, then compiles and visually checks them. The Sketch-to-Code Agent maps the sketch and instructions to an initial code sequence; the Editing Code Agent applies modification instructions while preserving structure; and the Check Agent compiles the code, detects syntax failures, and uses GPT-4o to compare the rendered diagram with the original sketch, sending failures back for regeneration. On the Sketch2Diagram test set the full system reaches 82.34 Pass@1 on generation and 93.12 on editing, and the ablation study attributes roughly one to two points of each to the compiler and the GPT-4o feedback loop, with both removed costing 3.82 points on generation. The paper frames this as the first end-to-end sketch-to-diagram pipeline, distinct from both photorealistic image generation and text-only code generation.

Load-bearing premise

The benchmark's 'sketches' are produced by stripping color and detail from already-compiled LaTeX diagrams, so the model is evaluated on clean, complete, structurally faithful renderings rather than on ambiguous, incomplete freehand drawings; if real hand-drawn input differs in line quality, overlap, and missing parts, the reported accuracy may not carry over.

Editorial extensions

If this is right

  • Sketch-to-diagram turns into a practical assistant: a user can draw a rough flowchart or architecture diagram and receive an editable LaTeX/TikZ source that compiles to a clean figure.
  • Diagram editing becomes instruction-driven: a user can ask for color, connection, or label changes and the Editing Code Agent updates the code rather than redrawing pixels.
  • The Sketch2Diagram benchmark gives the community a standardized split, token-level statistics, and metrics, so future sketch-to-diagram models can be compared directly.
  • If the multi-agent design generalizes, the same sketch-recognize-code-check pattern could apply to other structured outputs such as UML diagrams, circuit schematics, or floor plans.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The benchmark's sketches are render-simplified LaTeX outputs rather than genuine freehand strokes, so the reported numbers should be read as an upper bound; a genuine freehand test set could shift them substantially.
  • The larger gap between generation (82.34) and editing (93.12) suggests the system is strongest when an already-valid code base anchors the task, so real deployments may want to emphasize iterative editing of an initial scaffold.
  • The Check Agent's visual validation relies on GPT-4o, so part of the reported lead over baselines could reflect agreement with GPT-4o's own judging preferences; re-scoring outputs with human raters on identical generations would separate structural correctness from judge agreement.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. SketchAgent is a multi-agent pipeline for converting sketch images into structured diagrams represented as LaTeX/TikZ code. It comprises a Sketch-to-Code Agent (Qwen2-VL-7B) that maps a sketch and instruction set to code, an Editing Code Agent (Qwen2.5-Coder-7B) that applies editing instructions, and a Check Agent that compiles and iteratively validates the output with GPT-4o. The paper also introduces the Sketch2Diagram Benchmark, built by compiling open-source .tex diagrams, cropping and resizing them, and stripping colors and details to create the 'sketch' inputs. On this benchmark SketchAgent reports Pass@1 of 82.34 for sketch-to-code and 93.12 for editing, along with ablations and a human evaluation. The central claim is that the system automates the transformation of hand-drawn sketches into machine-readable diagrams.

Significance. If the benchmark inputs genuinely corresponded to hand-drawn sketches, this would be a valuable contribution: it would provide a standardized benchmark for sketch-to-diagram conversion and a strong modular baseline combining visual recognition, code generation, and iterative validation. The paper also has concrete strengths: the pipeline is clearly described, the benchmark is released, and the experiments compare many open- and closed-source models. However, the paper's own data-processing description shows that the benchmark 'sketches' are deterministic degradations of the target diagrams, not freehand drawings. The reported Pass@1 therefore does not currently establish the claimed advance, and the significance of the contribution is conditional on an evidential gap that the present manuscript does not fill.

major comments (4)
  1. [Section 4, Data Processing (and Figure 3)] The benchmark's 'sketches' are not hand-drawn: they are compiled .tex diagrams that are cropped, resized, and stripped of colors and details to produce simplified sketch representations. This turns the task into a deterministic inversion of a rendering pipeline rather than recognition of ambiguous freehand sketches. Consequently, the Pass@1 numbers in Tables 2 and 3 do not support the abstract's claim that SketchAgent automates the transformation of hand-drawn sketches into structured diagrams. The authors should either evaluate on a genuine hand-drawn test set or explicitly reframe the contribution as a diagram-simplification-to-code task.
  2. [Section 4, Human Inspection] The human-inspection guidelines explicitly require that images be 'clear, without blurriness or distortion' and 'complete, with no missing sections or truncation,' yet the introduction identifies ambiguity, variability, and incompleteness as the core challenges of sketch-to-diagram generation. Filtering out these properties removes the very difficulties the system claims to address, so the benchmark cannot measure progress on the stated problem.
  3. [Section 3.3 and Section 4, Data Processing] GPT-4o is used both to generate the benchmark queries and sketch codes during data construction and to serve as the Check Agent that judges whether the generated diagram matches the sketch and instructions. This shared-model evaluation creates a risk that the validator rewards outputs aligned with its own generation biases. An independent validator, human verification, or at least a measurement of agreement between GPT-4o and human judges is needed to support the reported Pass@1 results.
  4. [Section 4.1, Figure 5] The category distribution is extremely imbalanced: model architecture diagrams (52.34%) and directed graphs (42.5%) together account for more than 94% of the data, while flowchart, mind map, bar chart, and table categories are each below 0.3%. Aggregate Pass@1 is therefore dominated by two diagram types, and the claim of a comprehensive eight-category benchmark is not supported. Per-category results should be reported before drawing conclusions about the full benchmark.
minor comments (5)
  1. [Section 4.2] Pass@1 is not formally defined; please specify whether it means the generated code compiles, exactly matches the reference code, or passes some semantic equivalence check.
  2. [Table 3] The FID and KID values are reported without describing the reference image distribution; since the compilation step is deterministic, please clarify what visual fidelity is being measured and why a FID of 130.15 indicates 'strong visual coherence.'
  3. [Figure 7] The error-analysis examples are too small and low-resolution to be read in the manuscript; please provide enlarged crops or a supplementary figure.
  4. [References] The citations [Zhao and Lai, 2022] and [Zhao et al., 2024] appear to concern KNN density estimation and Byzantine-robust federated learning, respectively, and do not seem relevant to sketching or diagram generation; please verify and correct these references.
  5. [Section 5.1, Human Evaluation] The human evaluation reports only a figure; please provide the number of evaluated samples, the evaluator instructions, and inter-annotator agreement so that the results can be interpreted.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; benchmark-validity concerns are external, not logical.

full rationale

The paper presents an empirical system rather than a mathematical derivation, and I could not exhibit a specific reduction of a claim to its own inputs. The Sketch2Diagram benchmark does construct 'sketches' by stripping colors and details from compiled LaTeX diagrams, so the task is inverting a deterministic rendering pipeline rather than parsing true freehand input. This is a real external-validity concern, but it is not circularity: the target code is an independently compiled ground truth, not a fitted parameter of the model, and the held-out test split measures generalization within the same synthetic distribution. Similarly, GPT-4O both generates benchmark queries and serves as the final validator in the Check Agent, which could introduce bias, but the ablation study shows removing GPT-4O feedback changes Pass@1 by only 1.16 points, so it is not load-bearing. No self-citation chain or definitional identity between input and output was found; the paper does not import a uniqueness theorem or smuggle in an ansatz via citation. The central numerical results are therefore self-contained with respect to the benchmark they define, even though the benchmark does not support the broader 'hand-drawn' claim.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The system is a trained ML pipeline, so there are no explicit fitted constants in the paper. However, the benchmark construction relies on the assumption that simplified rendered diagrams capture freehand sketch variability, which is not validated.

assumptions (3)
  • ad hoc to paper Stripped diagram images are a valid proxy for hand-drawn sketches.
    Section 4 creates sketches by removing colors and details from compiled diagrams, yet the paper calls them hand-drawn without validation against real sketch distributions.
  • domain assumption GPT-4O can generate unbiased sketch codes and queries for the benchmark.
    Section 4 uses GPT-4O to generate 'sketch codes' and queries, but GPT-4O is also used as the Check Agent's evaluator, so its judgments are not independent.
  • domain assumption Compiled LaTeX diagrams represent the full space of user-intended sketches.
    The dataset is scraped from open-source .tex files (Section 4), which may not cover typical hand-drawn diagram styles like freeform boxes, arrows, and annotations.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SketchAgent: Generating Structured Diagrams from Hand-Drawn Sketches." pith.science (2026). https://pith.science/paper/YU6BYHSH

@misc{pith2026250801237,
  author       = {Pith},
  title        = {Pith review of: SketchAgent: Generating Structured Diagrams from Hand-Drawn Sketches},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YU6BYHSH}},
  note         = {Machine review of arXiv:2508.01237}
}
read the original abstract

Hand-drawn sketches are a natural and efficient medium for capturing and conveying ideas. Despite significant advancements in controllable natural image generation, translating freehand sketches into structured, machine-readable diagrams remains a labor-intensive and predominantly manual task. The primary challenge stems from the inherent ambiguity of sketches, which lack the structural constraints and semantic precision required for automated diagram generation. To address this challenge, we introduce SketchAgent, a multi-agent system designed to automate the transformation of hand-drawn sketches into structured diagrams. SketchAgent integrates sketch recognition, symbolic reasoning, and iterative validation to produce semantically coherent and structurally accurate diagrams, significantly reducing the need for manual effort. To evaluate the effectiveness of our approach, we propose the Sketch2Diagram Benchmark, a comprehensive dataset and evaluation framework encompassing eight diverse diagram categories, such as flowcharts, directed graphs, and model architectures. The dataset comprises over 6,000 high-quality examples with token-level annotations, standardized preprocessing, and rigorous quality control. By streamlining the diagram generation process, SketchAgent holds great promise for applications in design, education, and engineering, while offering a significant step toward bridging the gap between intuitive sketching and machine-readable diagram generation. The benchmark is released at https://huggingface.co/datasets/DiagramAgent/Sketch2Diagram-Benchmark.

Figures

Figures reproduced from arXiv: 2508.01237 by the authors.

Figure 1
Figure 1. SketchAgent automates the transformation of hand-drawn sketches into structured diagrams. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The SketchAgent pipeline, consisting of three main modules: Sketch-to-Code Agent, Editing Code Agent, and Check Agent. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The data collection and processing pipeline for the Sketch2Diagram Benchmark. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Examples of diagram types in the Sketch2Diagram. [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Category distribution in Sketch2Diagram. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Human evaluation results for different models on diagram [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: The error examples of SketchAgent. Misidentified elements refer to errors in recognizing indi￾vidual components of a sketch. For instance, the model may distort characters, fail to reproduce their correct proportions, or misrepresent attributes such as font style or or…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. ResearchPulse: Building Method-Experiment Chains through Multi-Document Scientific Inference

    cs.CL 2025-09 conditional novelty 5.0 of 10

    ResearchPulse extracts motivation-method chains and experimental trends from related papers, rendering them as mind maps and line charts, and releases a 100-cluster benchmark; the reported '7B beats GPT-4o' result is ...

Reference graph

Works this paper leans on

38 extracted references · 19 linked inside Pith · cited by 1 Pith paper

  1. [1]

    Phi-3 technical report: A highly capable language model locally on your phone

    [Abdin et al., 2024] Marah Abdin, Jyoti Aneja, Hany Awadalla, Ahmed Awadallah, Ammar Ahmad Awan, Nguyen Bach, Amit Bahree, Arash Bakhtiari, Jianmin Bao, Harkirat Behl, et al. Phi-3 technical report: A highly capable language model locally on your phone. arXiv preprint arXiv:2404.14219,

    arXiv 2024

  2. [5]

    Multidiffusion: Fusing diffusion paths for controlled image generation

    [Bar-Tal et al., 2023] Omer Bar-Tal, Lior Yariv, Yaron Lip- man, and Tali Dekel. Multidiffusion: Fusing diffusion paths for controlled image generation. ICLR,

    2023

  3. [7]

    Controllable generation with text-to- image diffusion models: A survey

    [Cao et al., 2024] Pu Cao, Feng Zhou, Qing Song, and Lu Yang. Controllable generation with text-to- image diffusion models: A survey. arXiv preprint arXiv:2403.04279,

    arXiv 2024

  4. [8]

    Codet: Code generation with generated tests

    [Chen et al., 2022] Bei Chen, Fengji Zhang, Anh Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. Codet: Code generation with generated tests. arXiv preprint arXiv:2207.10397,

    arXiv 2022

  5. [10]

    Automated generation of er diagram from a given text in natural lan- guage

    [Ghosh et al., 2018] Sutirtha Ghosh, Prasenjit Mukherjee, Baisakhi Chakraborty, and Rezaul Bashar. Automated generation of er diagram from a given text in natural lan- guage. In iCMLDE, pages 91–96. IEEE,

    2018

  6. [12]

    Cogvlm2: Vi- sual language models for image and video understanding

    [Hong et al., 2024] Wenyi Hong, Weihan Wang, Ming Ding, Wenmeng Yu, Qingsong Lv, Yan Wang, Yean Cheng, Shiyu Huang, Junhui Ji, Zhao Xue, et al. Cogvlm2: Vi- sual language models for image and video understanding. arXiv preprint arXiv:2408.16500,

    arXiv 2024

  7. [13]

    Controllable image synthesis methods, applications and challenges: a compre- hensive survey

    [Huang et al., 2024] Shanshan Huang, Qingsong Li, Jun Liao, Shu Wang, Li Liu, and Lian Li. Controllable image synthesis methods, applications and challenges: a compre- hensive survey. Artificial Intelligence Review, 57(12):336,

    2024

  8. [14]

    [Hui et al., 2024] Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, et al. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186,

    arXiv 2024

Show all 38 references
  1. [15]

    Self-planning code generation with large language models

    [Jiang et al., 2024] Xue Jiang, Yihong Dong, Lecheng Wang, Zheng Fang, Qiwei Shang, Ge Li, Zhi Jin, and Wenpin Jiao. Self-planning code generation with large language models. ACM Transactions on Software Engi- neering and Methodology, 33(7):1–30,

    2024

  2. [16]

    Coderl: Mastering code generation through pretrained models and deep reinforcement learning

    [Le et al., 2022] Hung Le, Yue Wang, Akhilesh Deepak Got- mare, Silvio Savarese, and Steven Chu Hong Hoi. Coderl: Mastering code generation through pretrained models and deep reinforcement learning. NeurIPS, 35:21314–21328,

    2022

  3. [17]

    Controllable text-to- image generation

    [Li et al., 2019] Bowen Li, Xiaojuan Qi, Thomas Lukasiewicz, and Philip Torr. Controllable text-to- image generation. NeurIPS, 32,

    2019

  4. [19]

    Starcoder 2 and the stack v2: The next generation

    [Lozhkov et al., 2024] Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, et al. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173,

    2024 arXiv

  5. [20]

    Wizardcoder: Em- powering code large language models with evol-instruct

    [Luo et al., 2023] Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. Wizardcoder: Em- powering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568,

    2023 arXiv

  6. [21]

    Cotext: Multi-task learning with code-text transformer

    [Phan et al., 2021] Long Phan, Hieu Tran, Daniel Le, Hieu Nguyen, James Anibal, Alec Peltekian, and Yanfang Ye. Cotext: Multi-task learning with code-text transformer. arXiv preprint arXiv:2105.08645,

    2021 arXiv

  7. [22]

    Code llama: Open foundation models for code

    [Roziere et al., 2023] Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950,

    2023 arXiv

  8. [23]

    Natural language to code translation with execution.arXiv preprint arXiv:2204.11454,

    [Shi et al., 2022] Freda Shi, Daniel Fried, Marjan Ghazvininejad, Luke Zettlemoyer, and Sida I Wang. Natural language to code translation with execution.arXiv preprint arXiv:2204.11454,

    2022 arXiv

  9. [24]

    A sur- vey of automatic code generation from natural language

    [Shin and Nam, 2021] Jiho Shin and Jaechang Nam. A sur- vey of automatic code generation from natural language. Journal of Information Processing Systems , 17(3):537– 555,

    2021

  10. [25]

    Moma: Multimodal llm adapter for fast personalized image gener- ation

    [Song et al., 2025] Kunpeng Song, Yizhe Zhu, Bingchen Liu, Qing Yan, Ahmed Elgammal, and Xiao Yang. Moma: Multimodal llm adapter for fast personalized image gener- ation. In ECCV, pages 117–132. Springer,

    2025

  11. [26]

    Peer review as a multi-turn and long-context dialogue with role-based interactions

    [Tan et al., 2024] Cheng Tan, Dongxin Lyu, Siyuan Li, Zhangyang Gao, Jingxuan Wei, Siqi Ma, Zicheng Liu, and Stan Z Li. Peer review as a multi-turn and long-context dialogue with role-based interactions. arXiv preprint arXiv:2406.05688,

    2024 arXiv

  12. [27]

    Gemini 1.5: Unlocking multimodal understand- ing across millions of tokens of context

    [Team et al., 2024] Gemini Team, Petko Georgiev, Ving Ian Lei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, et al. Gemini 1.5: Unlocking multimodal understand- ing across millions of tokens of context. arXiv preprint arXiv:2403.05530,

    2024 arXiv

  13. [28]

    Qwen2: A scalable and ver- satile language model

    [Team, 2024] Qwen Team. Qwen2: A scalable and ver- satile language model. https://qwenlm.github.io/zh/blog/ qwen2/,

    2024

  14. [29]

    Verigen: A large lan- guage model for verilog code generation

    [Thakur et al., 2024] Shailja Thakur, Baleegh Ahmad, Ham- mond Pearce, Benjamin Tan, Brendan Dolan-Gavitt, Ramesh Karri, and Siddharth Garg. Verigen: A large lan- guage model for verilog code generation. ACM Trans. on Design Automation of Electronic Systems, 29(3):1–31,

    2024

  15. [30]

    Structcoder: Structure-aware trans- former for code generation

    [Tipirneni et al., 2024] Sindhu Tipirneni, Ming Zhu, and Chandan K Reddy. Structcoder: Structure-aware trans- former for code generation. ACM Trans. on Knowledge Discovery from Data, 18(3):1–20,

    2024

  16. [31]

    Qwen2-vl: Enhanc- ing vision-language model’s perception of the world at any resolution

    [Wang et al., 2024] Peng Wang, Shuai Bai, Sinan Tan, Shi- jie Wang, Zhihao Fan, Jinze Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, et al. Qwen2-vl: Enhanc- ing vision-language model’s perception of the world at any resolution. arXiv preprint arXiv:2409.12191,

    2024 arXiv

  17. [32]

    Mm-diff: High-fidelity image per- sonalization via multi-modal condition integration

    [Wei et al., 2024b] Zhichao Wei, Qingkun Su, Long Qin, and Weizhi Wang. Mm-diff: High-fidelity image per- sonalization via multi-modal condition integration. arXiv preprint arXiv:2403.15059,

    arXiv

  18. [33]

    From words to structured visuals: A benchmark and framework for text-to-diagram generation and editing

    [Wei et al., 2025] 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. CVPR,

    2025

  19. [34]

    Baichuan 2: Open large- scale language models

    [Yang et al., 2023] Aiyuan Yang, Bin Xiao, Bingning Wang, Borong Zhang, Ce Bian, Chao Yin, Chenxu Lv, Da Pan, Dian Wang, Dong Yan, et al. Baichuan 2: Open large- scale language models. arXiv preprint arXiv:2309.10305,

    2023 arXiv

  20. [35]

    Internlm-xcomposer: A vision-language large model for advanced text-image comprehension and composition

    [Zhang et al., 2023a] Pan Zhang, Xiaoyi Dong, Bin Wang, Yuhang Cao, Chao Xu, Linke Ouyang, Zhiyuan Zhao, Haodong Duan, Songyang Zhang, Shuangrui Ding, et al. Internlm-xcomposer: A vision-language large model for advanced text-image comprehension and composition. arXiv preprint...

    arXiv

  21. [36]

    Controllable text-to-image generation with gpt-4

    [Zhang et al., 2023b] Tianjun Zhang, Yi Zhang, Vibhav Vineet, Neel Joshi, and Xin Wang. Controllable text-to-image generation with gpt-4. arXiv preprint arXiv:2305.18583,

    arXiv

  22. [37]

    Analysis of knn density estimation

    [Zhao and Lai, 2022] Puning Zhao and Lifeng Lai. Analysis of knn density estimation. IEEE Transactions on Informa- tion Theory, 68(12):7971–7995,

    2022

  23. [38]

    A huber loss minimization approach to byzantine robust federated learning

    [Zhao et al., 2024] Puning Zhao, Fei Yu, and Zhiguo Wan. A huber loss minimization approach to byzantine robust federated learning. In AAAI, 2024

    2024

  24. [2018]

    Deepseek-coder: When the large language model meets programming–the rise of code intelligence

    [Guo et al., 2024] Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. Deepseek-coder: When the large language model meets programming–the rise of code intelligence. arXiv preprint arXiv:2401.14196,

    2024 arXiv

  25. [2019]

    Llava-v1.6- 34b: Large multimodal language vision model

    [Liu and Others, 2025] Haotian Liu and Others. Llava-v1.6- 34b: Large multimodal language vision model. https:// huggingface.co/liuhaotian/llava-v1.6-34b,

    2025

  26. [2021]

    Palp: prompt aligned person- alization of text-to-image models

    [Arar et al., 2024] Moab Arar, Andrey V oynov, Amir Hertz, Omri Avrahami, Shlomi Fruchter, Yael Pritch, Daniel Cohen-Or, and Ariel Shamir. Palp: prompt aligned person- alization of text-to-image models. In SIGGRAPH, pages 1–11,

    2024

  27. [2022]

    Diffusion self- guidance for controllable image generation

    [Epstein et al., 2023] Dave Epstein, Allan Jabri, Ben Poole, Alexei Efros, and Aleksander Holynski. Diffusion self- guidance for controllable image generation. NeurIPS, 36:16222–16239,

    2023

  28. [2023]

    Internlm2 technical report

    [Cai et al., 2024] Zheng Cai, Maosong Cao, Haojiong Chen, Kai Chen, Keyu Chen, Xin Chen, Xun Chen, Zehui Chen, Zhi Chen, Pei Chu, et al. Internlm2 technical report. arXiv preprint arXiv:2403.17297,

    2024 arXiv

  29. [2024]

    Gpt-4 technical report

    [Achiam et al., 2023] Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Alt- man, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774,

    2023 arXiv

  30. [2025]

    Class diagram generation from text requirements: An application of natural language processing

    [Almazroi et al., 2021] Abdulwahab Ali Almazroi, Laith Abualigah, Mohammed A Alqarni, Essam H Houssein, Ahmad Qasim Mohammad AlHamad, and Mohamed Abd Elaziz. Class diagram generation from text requirements: An application of natural language processing. Deep Learning Approache...

    2021

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.