Autoregressive Generation of Static and Growing Trees

Biao Zhang; Dominik L. Michels; Dongming Yan; Hanxiao Wang; Jonathan Klein; Peter Wonka

REVIEW 5 major objections 5 minor 3 references

Autoregressive Generation of Static and Growing Trees

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

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

Pith's one-line read HourglassTree claims that autoregressive generation of tree skeletons becomes efficient and high-quality when branches are ordered by depth-first traversal and processed by a multi-resolution hourglass transformer, cutting memory and…

desk verdict Plausible method, real efficiency gain, but generation-quality evidence is under-specified and the 'first' claim contradicts the paper's own related work. read the letter →

arxiv 2502.04762 v1 pith:QQ75IJ5J submitted 2025-02-07 cs.CV

Hanxiao Wang , Biao Zhang , Jonathan Klein , Dominik L. Michels , Dongming Yan , Peter Wonka This is my paper · ORCID

classification cs.CV

keywords treegenerationhourglasstransformerautoregressive3Dskeletonstokenorderinggrowthsimulationpointcloudtoimage

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

This paper tries to establish that tree generation, long a procedural-modeling problem, can be done by an autoregressive transformer if the tree is represented compactly as an ordered set of branches and processed at multiple resolutions. The authors claim their hourglass-shaped transformer, HourglassTree, generates realistic tree skeletons with up to 1,000 branches, using roughly 2.5x less GPU memory and about half the training time of a same-depth plain transformer, while also supporting conditional generation from images, sketches, and point clouds and the synthesis of 10-stage growth sequences. If correct, this matters because trees are hierarchical, recursive structures that previous deep generative models handled only through indirect representations such as L-systems or voxels; a native branch-level representation with a causal ordering makes the structure itself the modeling language.

What carries the argument

The load-bearing object is the hourglass transformer with two token-level downsampling stages and shifted skip connections: the first downsampling merges a quadruple of x/y/z/r tokens into a single vertex token, the second merges the two endpoint tokens of a branch into one branch token, and the bottleneck processes the shortest sequence, with a learnable residual added to its later layers. Depth-first search ordering of branches supplies the causal structure that makes the autoregressive loss meaningful, ensuring each branch's prediction can condition on its ancestors; the paper's ablations show that swapping this ordering for zyx or Hilbert ordering collapses generation quality.

What would settle it

Take the trained HourglassTree model and generate a batch of trees, then compare branch-length distribution, radius taper, branching angle, and parent-child radius ratio against a set of real tree skeletons obtained from terrestrial LiDAR scans; if the joint distribution of these statistics differs substantially from the simulator's, the reported FID against simulator data overstates how well the model captures real tree structure. A second observable check: train the identical pipeline on real scanned skeletons of the same species and report whether FID and connectivity degrade relative to the simulator-trained numbers.

Watch

Extended reading notes

Core claim

The central claim is that depth-first ordering plus hourglass downsampling turns tree skeletons into a sequence that a standard autoregressive cross-entropy model can learn directly and efficiently. Each branch becomes two endpoints with coordinates and radius, each value quantized to 256 bins, and a depth-first traversal of the parent-child branch graph fixes the token order; this ordering alone improves FID from 36.30 (zyx) to 5.64 (DFS) on elm trees and connectivity from 0.2290 (Hilbert) to 0.9866 (DFS). The hourglass architecture then compresses the token sequence by merging four coordinate tokens into a vertex and two vertices into a branch, so the bottleneck layers see far fewer tokens, cutting GPU memory from 15.9G to 6.1G per GPU and training time from 10m15s to 5m21s while improving FID from 9.111 to 5.641 over the plain transformer. The same token sequence can be conditioned on an image, a sketch, a partial tree, or a point cloud, and ten growth stages concatenated in chronological order let the model generate 4D growing trees.

Load-bearing premise

The load-bearing assumption is that trees produced by the Rhizomorph simulator are representative of real tree structures, so all FID, MMD-CD, JSD, and connectivity scores measured against held-out simulator samples stand in for real-world generation quality.

Editorial extensions

If this is right

Branch-level tokenization lets the model generate trees with up to 1,000 branches, well beyond the roughly 1,600 faces that prior autoregressive mesh generators can handle, because one branch costs only 8 tokens.
The hoursglass architecture's memory and speed gains are the enablers: same-depth plain transformer uses 15.9G x 4 GPU memory and 10m15s per epoch, while HourglassTree uses 6.1G x 4 and 5m21s.
DFS ordering is a causal, parent-before-child sequence and is critical for quality; FID drops from 36.30 with zyx ordering to 5.64 with DFS, and connectivity rises from 0.6233 to 0.9866.
Conditional generation is achieved by prepending condition tokens extracted from an image, a sketch, a partial tree, or a point cloud, and the model completes or converts them autoregressively.
Growth dynamics are modeled by concatenating ten stage-wise token lists in chronological order, so the autoregressive model learns inter-stage transitions and can generate full 4D growth trajectories.

Reading between the lines

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

The ordering result is likely a general principle: any autoregressive generator over hierarchical data should order tokens so that ancestors precede descendants; applying DFS-style ordering to other branching structures (river networks, vascular systems, L-systems) should show similar FID/connectivity gaps, which would be a cheap and direct test.
The paper's quality metrics are computed against held-out Rhizomorph simulator samples, not real scanned trees; training the same architecture on real tree skeletons (terrestrial LiDAR) and comparing FID/connectivity would reveal how much of the reported quality depends on the simulator's branch statistics.
Because the skeleton is a compact cylinder set and leaves are added procedurally, an obvious extension is to use the same conditional autoregressive mechanism to generate leaf placement from the skeleton, something the paper leaves implicit.
The hourglass downsampling recipe is a generic sequence-compression strategy; it should transfer to other long sequences whose tokens can be hierarchically grouped, such as molecule graphs or urban road networks, where coarser grouping rules are known.

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.

Desk Editor's Note

read the letter

Quick take: HourglassTree is a plausible and potentially useful method for tree generation, with a clean branch-endpoint representation and a real efficiency gain from the hourglass transformer. But as submitted, the generation-quality numbers are not auditable, and the paper overreaches with its 'first deep generative approach' claim.

What's actually new: representing a tree as ordered branch endpoint tokens (two 4-vectors per branch), using DFS/BFS traversal to impose a causal parent-child order, and pairing that with an hourglass transformer that downsamples token sequences. The ordering study (Table 1) is the strongest part: DFS and BFS dramatically beat zyx and Hilbert on both FID and connectivity. That result is a concrete, useful finding for anyone doing autoregressive structured output. The hourglass ablation (Table 2) shows a clean ~2x training-time and ~2.6x memory reduction over a plain transformer at the same depth, which is a direct architectural measurement that does not depend on the quality metrics. The applications—tree completion, image-to-tree, point-cloud-to-tree, growth sequences—are reasonable extensions and the figures look plausible.

The soft spots are mostly about evidence presentation. FID on tree meshes is never defined: no rendering pipeline, views, or feature layer. MMD-CD, COV-CD, and JSD need point-sampling details that aren't there. Connect, Novel, Unique have no formal definitions. There are no error bars or repeated runs, and no code or data released. So Table 2's quality improvements (FID 5.64 vs 9.11) cannot be independently checked. More troubling, the paper claims to outperform DeepTree, Latent L-systems, Tree-D, and SVDTree, but reports zero quantitative comparison against any of them. And the 'first deep generative approach tailored to tree structures' claim is contradicted by their own related work, which lists those very methods. Finally, the training and test sets both come from the Rhizomorph simulator, so the quality metrics measure fit to that simulator's distribution, not to real trees. That limits the external validity of the quality story, though not the efficiency story.

Net: the architecture and ordering insights are worth publishing, but the evaluation needs major work. The efficiency claim is solid; the quality claim is unverifiable as reported. I'd send it to peer review with the expectation of heavy revision: define every metric, add at least one baseline comparison, provide error bars, release code/data (or detailed preprocessing), and either temper or evidence the 'first' claim. If they do that, it becomes a genuinely useful paper for graphics and vision researchers working on structured generation. If not, I'd only trust the speed/memory numbers.

Referee Report

5 major / 5 minor

Summary. The paper proposes HourglassTree, an autoregressive transformer for generating 3D tree skeletons represented as ordered sequences of quantized branch endpoints. The main claimed contributions are a DFS/BFS token ordering that captures parent-child structure, an hourglass-shaped transformer that reduces sequence length in middle layers for lower memory and faster training than a plain transformer, and extensions to conditional generation (image-to-tree, point-cloud-to-tree, completion) and to multi-stage 4D growth sequences. The empirical section reports FID, MMD-CD, COV-CD, JSD, Connect, Novel, Unique, and efficiency numbers, with an ablation showing the hourglass variants improve FID from 9.111 to 5.641 while reducing training time from about 10 minutes to about 5 minutes and GPU memory from 15.9G to 6.1G per GPU. The paper does not release code or data and does not report comparisons to prior deep tree generators.

Significance. If the efficiency and quality results are correct, the hourglass design combined with DFS token ordering would be a practically useful step for autoregressive generation of structured, branching geometry, and the 4D growth and conditional-generation extensions are appealing. The paper contains a direct, internally consistent ablation that supports the memory/time advantage of the hourglass architecture, and the DFS ordering experiment shows a large effect on the reported connectivity metric. However, the central quality claims are currently unverifiable because the metrics are not defined, no baselines against prior tree generators are reported, and the evaluation is entirely self-referential with respect to the Rhizomorph simulator used to create both training and test data. The efficiency claim is the strongest supported part; the quality claims need substantially more evidence.

major comments (5)

[Section 4.1, Tables 1, 3, 4, 5] The quantitative evaluation is underspecified to the point of being non-reproducible. FID, MMD-CD, COV-CD, JSD, IoU, Precision, Recall, and F1 are given only one-line prose definitions; the paper never states how tree meshes are rendered for FID, which views or Inception features are used, how point clouds are sampled for Chamfer distance, how distributions are estimated for MMD/JSD, or what formula and threshold define the 'Connect' metric. Because these metrics carry the generation-quality claim, the reported numbers cannot be checked by a reader.
[Introduction, item (1) and Section 2 (Related Work)] The paper claims that this is 'the first deep generative solution specifically designed for tree-structured data,' but its own Related Work describes Lee et al. 2023 (Latent L-systems, a transformer-based tree generator) and Zhou et al. 2023 (DeepTree, deep learning for tree generation) as deep learning methods for trees. This novelty claim is internally contradicted and needs to be substantially weakened or clarified.
[Section 2 and Section 4.2] No quantitative comparison is reported against any prior deep tree generator, despite the paper naming DeepTree, Latent L-systems, Tree-D, and SVDTree. The abstract and introduction claim higher-quality generation than prior methods, but the experiments only compare the proposed model variants against each other. Adding at least one or two of these methods under the same metric protocol is necessary to support the superiority claims.
[Section 4, data generation paragraph] All training and held-out test samples come from the Rhizomorph simulator of Li et al. 2023. Consequently, the FID, MMD-CD, COV-CD, and JSD values measure how closely the model matches that simulator's distribution, not how botanically plausible or realistic the trees are relative to real scanned trees. The paper should either evaluate on real tree data or carefully restrict the claims to 'match to the training simulator distribution'.
[Table 2 and Section 4.2.2] The architecture ablation reports no error bars, no repeated runs, and no variation of sequence length or model scale, so the speed and memory improvements are established only for a single configuration on a single dataset. The efficiency claim would be stronger with multiple seeds, confidence intervals, and at least one additional tree species or sequence length to show the trend is stable.

minor comments (5)

[Abstract and Section 3.2.4] There are several typos: 'completent' in the abstract should be 'complement', 'and and Self-Attention' in the Section 3.2.4 heading should be 'and Self-Attention', and 'Similarily' should be 'Similarly'.
[Section 3.2.1] The phrase 'structured trees with inherent structural' appears incomplete; please revise to a complete sentence.
[Section 3.2.3, Eq. (1)] The learned scale alpha is introduced without specifying its initialization, dimensionality, or any regularization; a sentence on these details would clarify the mechanism.
[Section 4.2.4] The sentence 'We trained 6 models for each species, including Vitellaria, Hickory, Shadbush, Spruce, and Tulip' lists only five species; clarify whether Elm is the sixth and why it is listed separately in Table 1.
[Figure 4] Figure 4 shows quantization at 64, 256, and 1024 levels, but the text states that 256 bins are used; please explain whether the figure illustrates an ablation or a conceptual comparison.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: efficiency claims are direct measurements and quality scores are held-out evaluations against the stated simulator distribution; underspecification is a reproducibility issue, not circularity.

full rationale

The paper contains no analytic derivation in which a predicted quantity equals an input by construction. Its central claims are empirical: the hourglass transformer is faster and uses less memory (Tables 1-2, with direct wall-clock and GPU-memory measurements) and generates quantized branch sequences with lower FID/MMD/JSD (Tables 1, 3, 4). These quality metrics are computed against a held-out split of the same Rhizomorph-generated dataset used for training; while that makes the evaluation self-referential with respect to real-world trees, it is standard train/test evaluation of a generative model and not a fitted parameter renamed as a prediction. The citation to Li et al. 2023 for the simulator is a code-reproduced external data source with overlapping authors, but it does not assume or entail HourglassTree's results, so it is not load-bearing self-citation. Undefined metric details (how FID is computed on meshes, what 'Connect' measures) and the absence of numbers for prior tree generators are reproducibility and support concerns, not circularity. No uniqueness theorem or ansatz is smuggled in via citation; the hourglass architecture is attributed to prior work and empirically ablated.

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

The paper's central claims depend on a synthetic-data proxy, a simplified branch representation, a manually chosen tokenization and ordering, and several unspecified evaluation details. There are no new physical entities; the main burden is the simulator-as-ground-truth assumption and the unexposed metric implementations.

free parameters (5)

Quantization bins per continuous value = 256
Spatial coordinates and radii are quantized into 256 bins with separate per-axis boundary values (Sec. 3.1.2); bin boundaries are chosen from data statistics and are not specified, and quantization resolution directly limits geometric fidelity.
Maximum branches per tree per species = 200 (elm), 1000 (other species)
Dataset preprocessing caps branch count (Sec. 4), which sets the token sequence length and therefore bounds the 'more complex trees' claim.
Number of SOS/EOS control tokens = 8
8 [SOS] and 8 [EOS] tokens are prepended/appended (Sec. 3.1.2); this choice affects sequence alignment with downsampling factors and model capacity.
Learnable bottleneck scale alpha = learned during training
The scale parameter alpha in Eq. (1) is learned, and the ablation shows it improves FID from 5.996 to 5.641; it is a trained parameter of the architecture.
Point cloud query vectors = 50
The point-cloud-to-tree cross-attention uses 50 learnable query vectors (Sec. 4.4.3); this is a hand-chosen capacity parameter for the conditioning path.

assumptions (5)

domain assumption Simulator fidelity: trees generated by the Li et al. [2023] Rhizomorph model are a valid proxy for real tree geometry and growth
The entire training and test set is synthetic from this simulator (Sec. 4, 'The training dataset was generated using the provided source code...'); no real scanned trees are used.
domain assumption Branch-endpoint parameterization (two points with radii) is sufficient to represent trees, with leaves added procedurally
The representation in Sec. 3.1.1 discards leaf geometry and any branch curvature, assuming cylinders between endpoints capture the structure.
domain assumption DFS token ordering encodes all structural dependencies needed by causal attention
Sec. 3.1.3 claims traversal ensures each branch inherits information from ancestors; this assumes no critical cross-subtree dependency is lost by linearization.
ad hoc to paper Quantization into 256 bins with per-coordinate boundaries preserves structural fidelity
Sec. 3.1.2 and Fig. 4: the choice of bin boundaries is data-driven and not derived; generation quality is bounded by this discretization.
domain assumption The 'Connect' and FID/MMD metrics as computed on token-to-mesh conversions measure meaningful tree quality
Metric definitions in Sec. 4.1 are one-liners; the exact FID feature space and Connect computation are not specified, so the assumed validity is unverifiable.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Autoregressive Generation of Static and Growing Trees." pith.science (2026). https://pith.science/paper/QQ75IJ5J

@misc{pith2026250204762,
  author       = {Pith},
  title        = {Pith review of: Autoregressive Generation of Static and Growing Trees},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QQ75IJ5J}},
  note         = {Machine review of arXiv:2502.04762}
}

read the original abstract

We propose a transformer architecture and training strategy for tree generation. The architecture processes data at multiple resolutions and has an hourglass shape, with middle layers processing fewer tokens than outer layers. Similar to convolutional networks, we introduce longer range skip connections to completent this multi-resolution approach. The key advantage of this architecture is the faster processing speed and lower memory consumption. We are therefore able to process more complex trees than would be possible with a vanilla transformer architecture. Furthermore, we extend this approach to perform image-to-tree and point-cloud-to-tree conditional generation and to simulate the tree growth processes, generating 4D trees. Empirical results validate our approach in terms of speed, memory consumption, and generation quality.

Figures

Figures reproduced from arXiv: 2502.04762 by the authors.

**Figure 1.** We introduce a data structure, transformer architecture, and training strategy for the autoregressive generation [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗

**Figure 4.** Different resolutions of data quantization. [PITH_FULL_IMAGE:figures/full_fig_p003_4.png] view at source ↗

**Figure 2.** Architecture of our HourglassTree method [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

Figures from the paper (7 more)

**Figure 3.** Figure 3: An illustration of our data structure. 64 256 1024 GT 0 0.01 [PITH_FULL_IMAGE:figures/full_fig_p003_3.png]

**Figure 6.** Figure 6: Tree structures generated using different token [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]

**Figure 7.** Figure 7: Tree structures generated using DFS token order. [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]

**Figure 10.** Figure 10: Point cloud to tree examples. This model sequentially generates the tree structure, guided by the constraints and features extracted from the input point cloud. As depicted in [PITH_FULL_IMAGE:figures/full_fig_p007_10.png]

**Figure 11.** Figure 11: Unconditional generation of different tree species. [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]

**Figure 12.** Figure 12: An illustration of tree completion. We show the input (left) and multiple different completions (right). [PITH_FULL_IMAGE:figures/full_fig_p010_12.png]

**Figure 13.** Figure 13: Unconditional generation of growing trees. [PITH_FULL_IMAGE:figures/full_fig_p010_13.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

3 extracted references · 1 canonical work pages

[2020]

arXiv:2011.13456 (2020)

Score-based generative modeling through stochastic differential equations. arXiv:2011.13456 (2020). O. Stava, S. Pirk, J. Kratt, B. Chen, R. Měch, O. Deussen, and B. Benes. 2014. Inverse procedural modelling of trees. In Computer Graphics Forum, Vol. 33. Wiley Online Library, 118–131. J. Tang, Z. Li, Z. Hao, X. Liu, G. Zeng, M.-Y. Liu, and Q. Zhang. 2024....

arXiv 2020
[2021]

In NeurIPS

Accurately Solving Rod Dynamics with Graph Learning. In NeurIPS. Y. Siddiqui, A. Alliegro, A. Artemov, T. Tommasi, D. Sirigatti, V. Rosov, A. Dai, and M. Nießner. 2024. Meshgpt: Generating triangle meshes with decoder-only trans- formers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 19615–19625. A. R. Smith. 1984. ...

work page 1984
[2024]

Point Transformer V3: Simpler, Faster, Stronger. In CVPR. B. Zhang, J. Tang, M. Niessner, and P. Wonka. 2023. 3dshape2vecset: A 3d shape representation for neural fields and generative diffusion models. ACM Transactions on Graphics (TOG) 42, 4 (2023), 1–16. B. Zhang and P. Wonka. 2024. Lagem: A large geometry model for 3d representation learning and diffu...

arXiv 2023

Pith tools

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

[1] [2020]

arXiv:2011.13456 (2020)

Score-based generative modeling through stochastic differential equations. arXiv:2011.13456 (2020). O. Stava, S. Pirk, J. Kratt, B. Chen, R. Měch, O. Deussen, and B. Benes. 2014. Inverse procedural modelling of trees. In Computer Graphics Forum, Vol. 33. Wiley Online Library, 118–131. J. Tang, Z. Li, Z. Hao, X. Liu, G. Zeng, M.-Y. Liu, and Q. Zhang. 2024....

arXiv 2020

[2] [2021]

In NeurIPS

Accurately Solving Rod Dynamics with Graph Learning. In NeurIPS. Y. Siddiqui, A. Alliegro, A. Artemov, T. Tommasi, D. Sirigatti, V. Rosov, A. Dai, and M. Nießner. 2024. Meshgpt: Generating triangle meshes with decoder-only trans- formers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 19615–19625. A. R. Smith. 1984. ...

work page 1984

[3] [2024]

Point Transformer V3: Simpler, Faster, Stronger. In CVPR. B. Zhang, J. Tang, M. Niessner, and P. Wonka. 2023. 3dshape2vecset: A 3d shape representation for neural fields and generative diffusion models. ACM Transactions on Graphics (TOG) 42, 4 (2023), 1–16. B. Zhang and P. Wonka. 2024. Lagem: A large geometry model for 3d representation learning and diffu...

arXiv 2023