Pith. sign in

REVIEW 4 major objections 3 minor 1 cited by

Language-to-Space Programming for Training-Free 3D Visual Grounding

T0 review · 4 major / 3 minor · reviewed 2026-08-09 · deepseek-v4-flash

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

Pith's one-line read LaSP compiles spatial relations into reusable Python code that grounds 3D objects at 52.9% accuracy without per-query LLM reasoning.

desk verdict Solid engineering with a misleading 'training-free' label; the benchmark-adapted code optimization is the real story, and the efficiency/accuracy trade-off is credible. read the letter →

arxiv 2502.01401 v4 pith:4GNQ4Q6N submitted 2025-02-03 cs.CV

Boyu Mi , Hanqing Wang , Tai Wang , Yilun Chen , Jiangmiao Pang This is my paper · ORCID
classification cs.CV
keywords 3Dvisualgroundingtraining-freemethodsspatialrelationencodingLLMcodegenerationtestsuiteoptimizationneuro-symbolicreasoningvision-languagemodelsReferIt3D
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

LaSP is a method for 3D visual grounding that moves spatial reasoning out of the per-query LLM/VLM loop and into reusable Python code. The authors call it training-free because it avoids large-scale, expensively annotated vision-language datasets: an LLM writes small programs—one per spatial relation—that score object pairs from 3D bounding boxes, then iteratively refines them against automatically built test suites drawn from only a few dozen Nr3D training triplets. On the Nr3D benchmark, LaSP reaches 52.9% accuracy with predicted object labels, ranking among the best training-free methods, while using roughly 7.7 seconds and 3.1k tokens per query versus 50.3 seconds and 8k tokens for the VLM-Grounder agent. The central claim is that spatial relation understanding can be compiled into small, optimized code and reused across all queries without sacrificing accuracy.

What carries the argument

The load-bearing object is the spatial relation encoder: a Python class, generated and optimized by an LLM, whose forward() method returns an N×N matrix of relation likelihoods from object bounding-box centers and sizes. The method's novelty is the self-improvement loop around these encoders—sampling many candidate codes, testing them against per-relation test suites built from training triplets, converting failures into error messages, and re-prompting the LLM to revise the code. The executor, adapted from neuro-symbolic grounding, combines the resulting relation features with category features according to a parsed symbolic expression; the VLM module is only a final disambiguator. This division of labor is what lets LaSP amortize the expensive LLM work into a one-time offline cost.

What would settle it

Take the per-relation training triplets for 'behind', split them into a selection set and a held-out set, and compare the encoder chosen by highest pass rate against a mid-pass-rate encoder on the held-out set; if the pass-rate-optimal encoder consistently scores lower, the test-suite selection rule on which the whole optimization pipeline depends is not a reliable guide.

Watch

Extended reading notes

Core claim

LaSP claims that spatial relations in 3D scenes are better encoded as executable geometry than as learned parameters or live LLM reasoning. For each relation (above, near, left, ...), the method samples multiple Python encoder classes from an LLM; each class takes object centers and sizes and returns an N×N tensor of relation likelihoods. An automatically constructed test suite, built from ground-truth triplets in the Nr3D training set (about 37 per relation), scores each candidate by pass rate; failed cases are turned into error messages, and the LLM revises the top-K codes over up to five iterations. The best encoder is frozen and reused at grounding time, where a symbolic parser converts the utterance into an expression that the executor evaluates by multiplying relation features with category features. A VLM then visually disambiguates the top candidates. This pipeline yields 52.9% overall accuracy on Nr3D (50.7% without the VLM), 67.8% when ground-truth object labels are used, and cuts grounding time and token use below agent-based approaches while staying competitive with the strongest training-free baselines.

Load-bearing premise

The pipeline rests on the assumption that a code's pass rate on a small curated test suite—roughly 37 training triplets per relation—accurately predicts how well that code will ground objects in unseen scenes; the paper's own Figure 12 shows this assumption already fails for the 'behind' relation, where the highest-pass-rate code answers fewer held-out test cases than a code with about 70% pass rate.

Editorial extensions

If this is right

  • Training-free grounding can match agent-based accuracy without per-query LLM reasoning: LaSP's 52.9% on Nr3D beats VLM-Grounder (48.0%) and SeeGround (46.1%) at roughly one-sixth the time per utterance.
  • The relation encoders transfer across scenes: on GRScenes with 40 manually annotated utterances, LaSP reaches 90.0% versus 15.6% for random same-category selection, suggesting the codes capture geometry rather than dataset quirks.
  • Automated code optimization beats human function design here: swapping in human-written spatial functions drops LaSP from 52.9% to 44.0% accuracy.
  • The optimization loop, not just the LLM's first attempt, is what delivers accuracy: without error-message guided refinement, most relations get weak encoders, and the detailed failure cases give the largest accuracy gains in the ablations.
  • View-dependent relations are handled implicitly: the encoders learn a data-driven 'facing the anchor' prior, and LaSP reaches 49.2% on the view-dependent Nr3D subset without explicit viewpoint modeling.

Reading between the lines

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

  • The same 'code as encoder, test suite as curriculum' recipe could be applied to other structured geometric predicates—orientation, support, functional zones—where training triplets can be synthesized from CAD models or simulators instead of human annotations.
  • Because the encoders are frozen and the executor alone runs in about 2.1 seconds per query, LaSP could be embedded in a robot or AR setting where the same scene is queried repeatedly, with the offline optimization cost fully amortized.
  • The 'behind' failure in the paper's Figure 12 suggests that pass-rate-based selection can overfit to small test suites; adding adversarial or dynamically expanded test cases would likely make the selection rule more robust on held-out scenes.
  • The architecture—symbolic parse, code-computed relation features, executor aggregation, VLM veto—is a general template that could transfer to 2D referring expressions or layout-based visual question answering, where spatial predicates can likewise be compiled into reusable programs.
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 / 3 minor

Summary. The paper proposes LASP, a 3D visual grounding method that encodes spatial relations as Python code generated and iteratively optimized by LLMs. Prior to inference, relation encoders are selected by pass rates on test suites constructed from Nr3D training-set triplets; at inference, a semantic parser converts the utterance into a symbolic expression, the encoders compute relation features from 3D bounding boxes, an executor computes matching scores, and a VLM disambiguates candidates from rendered images. Experiments on Nr3D report 52.9% overall accuracy with predicted labels (67.8% with ground-truth labels), substantially lower grounding time and token costs than agent-based baselines, and cross-dataset results on GRScenes. The paper includes ablations of the generation/optimization components and releases code.

Significance. If the accuracy and efficiency claims hold, the paper makes a useful engineering contribution: it replaces per-utterance LLM/VLM reasoning with pre-generated executable code, and it demonstrates that LLM-generated relation encoders can be selected and refined through automatically built test suites. The released code, the ablation study (Variant 1/2/3 in Fig. 8), and the cost measurements are concrete assets. The core idea of code-as-relation-encoder is plausible and potentially transferable. However, the headline 'training-free' claim and some baseline comparisons require qualification, because the encoders are optimized on the Nr3D training split and the VLM-Grounder baseline is drawn from a 250-sample subset. These issues do not invalidate the engineering contribution but do affect how the results should be framed and compared.

major comments (4)
  1. [Sec. 3.3.2, Footnote 1, Sec. 4.3] The paper calls LASP 'training-free,' but the relation encoders are selected and optimized on test suites built from 37 Nr3D training triplets per relation (Sec. 3.3.2), and the final encoder is the one with the highest pass rate on those suites (Algorithm 2). The redefinition in Footnote 1 does not remove the benchmark dependence: the offline optimization is performed on the same benchmark on which the headline 52.9% is reported, and Sec. 4.3 concedes that other training-free approaches use no external data at all. The comparison in Table 1 is therefore not apples-to-apples within the 'training-free' category. At minimum, report the overall accuracy of LASP without any test-suite optimization (the Variant 1 setting of Sec. 4.4) next to the optimized result, and relabel the method throughout as, for example, 'no network training' or 'few-example code optimization' rather than 'training-free.'
  2. [Sec. 4.2, Table 1] The VLM-Grounder result in Table 1 is taken from a 250-sample subset reported in the original paper (dagger), while LASP is evaluated on the full Nr3D test split. The 48.0% versus 52.9% comparison is therefore not a fair head-to-head. If VLM-Grounder is used to support the claim of 'ranking among the best training-free methods,' the authors should evaluate it on the same full test split or clearly exclude it from the ranking. In addition, no variance or repeated-run statistics are reported for LASP; given the stochasticity of LLM sampling (temperature 1.0) and VLM decisions, a single run is insufficient to support the claimed margin over baselines.
  3. [Table 1, CSVG row] The CSVG row in Table 1 is arithmetically inconsistent: overall accuracy 59.2 with easy 59.2, hard 44.5, view-dependent 53.0, and view-independent 46.4 cannot all describe the same test set, since the overall value should lie between the easy/hard values and between the view-dependent/view-independent values. Please verify the numbers and report the correct breakdown, or state explicitly that different columns come from different evaluation subsets.
  4. [Fig. 12, Appendix D.5] The selection rule central to Algorithm 2—pick the code with the highest pass rate on the test suite—fails for the 'behind' relation according to the paper's own Figure 12: the code with the highest training-suite pass rate solves about 15 fewer test examples than one with roughly 70% pass rate. This shows that the pass-rate proxy is noisy with only 37 triplets, and the reported accuracy may be sensitive to the particular suite composition and selection rule. Please report the accuracy of LASP under alternative top-k selections or across multiple suite draws to demonstrate that the headline 52.9% is not an artifact of one favorable encoder choice.
minor comments (3)
  1. [Sec. 1 and Fig. 1] There are several typos: 'demostrate' and 'desgined' in Sec. 1, 'signicicantly' in the Figure 1 caption, 'We evaluateLASP' in Sec. 4.2, and 'a automatic generation pipeline' in Sec. 5. Please copyedit the manuscript.
  2. [Sec. 4.3, Appendix D.6] The GRScenes evaluation uses only 40 manually annotated utterances across five scenes; the 90.0% accuracy should be interpreted with this small sample size in mind, and the paper should say so explicitly.
  3. [Sec. 3.4, Appendix B.6] Please state how the VLM decision threshold (0.9 for Nr3D) was chosen and whether it was tuned on the Nr3D training split; this hyperparameter affects the accuracy-cost trade-off of the VLM module.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the 52.9% Nr3D figure is measured on a held-out split after code selection on the training split; the stipulative 'training-free' label is a disclosed semantic choice, not a derivation.

full rationale

The paper's central quantitative claim is the 52.9% accuracy on Nr3D. The relation encoders are generated and optimized against test suites built from 37 Nr3D training triplets per relation (Sec. 3.3.2, Algorithm 2), and the headline accuracy is then reported on the Nr3D test split. This is a train/validation/test protocol rather than a circular reduction: the test labels are not used in code selection or optimization, so the reported accuracy is not forced by construction. The paper itself discloses the dependency: Sec. 4.3 states that 'it does exploit a small subset of the ReferIt3D corpus during optimization, whereas other training-free approaches use no external data at all,' and footnote 1 redefines 'training-free' as 'an approach that aims to eliminate the dependency on large-scale, expensively annotated vision-language datasets' while acknowledging that the method 'leverages a small set of examples.' That is a semantic re-labeling and a fair-comparison concern, but it does not make the measured test accuracy equivalent to the training-suite inputs. The Figure 12 'behind' result, where the highest-pass-rate code yields about 15 fewer correct test examples than a code with ~70% pass rate, is evidence of proxy fragility or overfitting to the 37-triplet suite; it is a robustness/correctness limitation, not circularity. The only overlapping-author citations (VLM-Grounder, GRScenes) are used for a visual decision module and an auxiliary generalization benchmark, respectively, and neither is the load-bearing justification for the main result. No uniqueness theorem or ansatz is smuggled in via self-citation. Accordingly, no step in the derivation chain reduces by definition to its own inputs, and the honest finding is no significant circularity.

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

The main new component is the code-based relation encoder, which is a software construct rather than an invented physical entity. The ledger shows that the method imports several modeling assumptions from prior work (executor design) and adds a data-dependent selection loop.

free parameters (5)
  • Nsample (code samples per iteration) = 5
    Number of LLM responses sampled per code-generation step; chosen by the authors (Appendix B.6).
  • Niter (optimization iterations) = 5
    Maximum iterations of test-and-optimize; set to 5 (Appendix B.6).
  • topk (codes kept for optimization) = 3
    Number of high-pass-rate codes passed to the optimization phase (Appendix B.6).
  • VLM decision threshold = 0.9
    Candidate logit threshold before VLM selection; tuned on Nr3D (Sec 3.4, B.6).
  • Test suite size per relation = up to 40 (e.g. 37 for above)
    Number of triplets drawn from Nr3D training set to define unit tests; a design choice affecting encoder selection (Sec 3.3.2).
assumptions (4)
  • domain assumption Spatial relations such as near, above, and left can be adequately encoded by deterministic Python functions of axis-aligned 3D bounding boxes.
    The entire relation-encoder pipeline (Sec 3.3) rests on this; the executor then multiplies these features with category features.
  • ad hoc to paper Test-suite pass rate on a few dozen training-derived triplets is a reliable proxy for encoder quality on held-out test scenes.
    The selection and optimization loop (Algorithm 2) assumes this. Figure 12 shows a counterexample for 'behind', where the highest pass-rate encoder underperforms on the test set.
  • domain assumption The fixed relation set (unary, binary, ternary) in Table 4 covers the spatial meaning of typical referring utterances.
    The semantic parser is forced to map any utterance into these relations, so inadequately covered relations such as ordinal phrases are acknowledged as a limitation.
  • domain assumption The product-based composition of category and relation features in the executor (Algorithm 1) approximates the semantics of conjunction in referring expressions.
    Borrowed from NS3D (Hsu et al., 2023) and applied unchanged.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Language-to-Space Programming for Training-Free 3D Visual Grounding." pith.science (2026). https://pith.science/paper/4GNQ4Q6N

@misc{pith2026250201401,
  author       = {Pith},
  title        = {Pith review of: Language-to-Space Programming for Training-Free 3D Visual Grounding},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4GNQ4Q6N}},
  note         = {Machine review of arXiv:2502.01401}
}
read the original abstract

3D visual grounding (3DVG) is challenging due to the need to understand 3D spatial relations. While supervised approaches have achieved superior performance, they are constrained by the scarcity and high annotation costs of 3D vision-language datasets. Training-free approaches based on LLMs/VLMs eliminate the need for large-scale training data, but they either incur prohibitive grounding time and token costs or have unsatisfactory accuracy. To address the challenges, we introduce a novel method for training-free 3D visual grounding, namely Language-to-Space Programming (LaSP). LaSP introduces LLM-generated codes to analyze 3D spatial relations among objects, along with a pipeline that evaluates and optimizes the codes automatically. Experimental results demonstrate that LaSP achieves 52.9% accuracy on the Nr3D benchmark, ranking among the best training-free methods. Moreover, it substantially reduces the grounding time and token costs, offering a balanced trade-off between performance and efficiency.

Figures

Figures reproduced from arXiv: 2502.01401 by the authors.

Figure 1
Figure 1. Accuracy and cost comparison of LASP (ours) with two types of existing training-free 3DVG methods. Agent-based methods input scene information into LLMs/VLMs to analyze spatial relations, leading to high accuracy but also high computational costs. Visual programming (Visprog.) only inputs the referring utterance into LLMs to generate a program and finds the target by program execution. It reduces the costs signicica… view at source ↗
Figure 2
Figure 2. Overview of LASP. Off-the-shelf spatial relation encoders are generated and optimized by LLMs before grounding. At the grounding time, the encoders compute relation features based on object bounding boxes. An executor uses the relation features, along with category features and the symbolic expression to get some candidate objects. Then LASP uses VLMs to select the target from their images. uses VLMs to find the tar… view at source ↗
Figure 4
Figure 4. Overview of the generation and optimization [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗
Figures from the paper (11 more)
Figure 3
Figure 3. Figure 3: Example of spatial relation encoder for rela [PITH_FULL_IMAGE:figures/full_fig_p004_3.png]
Figure 5
Figure 5. Figure 5: An example of stitched images for VLM prompting. Object ID is annotated on each object’s position. VLMs can figure out the target “red” box from the two candidates and output its ID. annotated utterances and the Sr3D contains synthe￾sized ones. Based on the number of s…
Figure 6
Figure 6. Figure 6: Visualization of the grounding process. Anchor (the door) is marked with [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: The LLM-based optimization of “front” rela [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Ablation study on different variants. The x-axis stands for the number of optimization iterations. The y-axis stands for the normalized accuracy on corresponding Nr3D subsets. the generated codes can pass all unit tests in the first generation, so there is no following…
Figure 9
Figure 9. Figure 9: The graph representation for in context exam [PITH_FULL_IMAGE:figures/full_fig_p016_9.png]
Figure 10
Figure 10. Figure 10: Example of code optimization result on rela [PITH_FULL_IMAGE:figures/full_fig_p017_10.png]
Figure 11
Figure 11. Figure 11: The target objects are: “Stove next to another stove and close to the fridge” (top row) and “Trashcan to [PITH_FULL_IMAGE:figures/full_fig_p019_11.png]
Figure 12
Figure 12. Figure 12: Corresponding relation between the unit test pass rate and number of correct examples on test set. [PITH_FULL_IMAGE:figures/full_fig_p019_12.png]
Figure 13
Figure 13. Figure 13: Relation feature examples. The features of “near” and “far” are symmetric, meaning mutual relationships [PITH_FULL_IMAGE:figures/full_fig_p020_13.png]
Figure 14
Figure 14. Figure 14: Qualitive results on GRScenes (Wang et al., 2024). The target object is in the green box and the visible distractors are indicated by the red box [PITH_FULL_IMAGE:figures/full_fig_p021_14.png]

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. SPAZER: Spatial-Semantic Progressive Reasoning Agent for Zero-shot 3D Visual Grounding

    cs.CV 2025-06 conditional novelty 6.0 of 10

    SPAZER, a VLM-driven agent, combines 3D rendered views with 2D camera images in a progressive pipeline to achieve state-of-the-art zero-shot 3D visual grounding.

Reference graph

Works this paper leans on

43 extracted references · 30 canonical work pages · cited by 1 Pith paper

  1. [1]

    Panos Achlioptas, Ahmed Abdelreheem, Fei Xia, Mohamed Elhoseiny, and Leonidas Guibas. 2020. ReferIt3D: Neural Listeners for Fine-grained 3D Object Identification in Real-world Scenes . In ECCV, pages 422--440. Springer

    work page 2020

  2. [2]

    Eslam Mohamed BAKR, Mohamed Ayman Mohamed, Mahmoud Ahmed, Habib Slim, and Mohamed Elhoseiny. 2024. https://openreview.net/forum?id=ORUiqcLpV6 Cot3 DR ef: Chain-of-thoughts data-efficient 3d visual grounding . In The Twelfth International Conference on Learning Representations

    work page 2024

  3. [3]

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, and 1 others. 2020. Language models are few-shot learners. Advances in neural information processing systems, 33:1877--1901

    2020

  4. [4]

    Dave Zhenyu Chen, Angel X Chang, and Matthias Nie ner. 2020. ScanRefer: 3D Object Localization in RGB-D Scans using Natural Language . In ECCV, pages 202--221. Springer

    work page 2020

  5. [5]

    Shizhe Chen, Pierre-Louis Guhur, Makarand Tapaswi, Cordelia Schmid, and Ivan Laptev. 2022. Language conditioned spatial relation reasoning for 3d object grounding. Advances in neural information processing systems, 35:20522--20535

    work page 2022

  6. [6]

    Xinyun Chen, Maxwell Lin, Nathanael Sch \"a rli, and Denny Zhou. 2024. https://openreview.net/forum?id=KuPixIqPiq Teaching large language models to self-debug . In The Twelfth International Conference on Learning Representations

    2024

  7. [7]

    Angela Dai, Angel X Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nie ner. 2017. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5828--5839

    work page 2017

  8. [8]

    Jiading Fang, Xiangshan Tan, Shengjie Lin, Igor Vasiljevic, Vitor Guizilini, Hongyuan Mei, Rares Ambrus, Gregory Shakhnarovich, and Matthew R Walter. 2024. Transcrib3d: 3d referring expression resolution through large language models. In 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 9737--9744. IEEE

    work page 2024

Show all 43 references
  1. [9]

    Chun Feng, Joy Hsu, Weiyu Liu, and Jiajun Wu. 2024. Naturally supervised 3d visual grounding with language-regularized concept learners. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13269--13278

    2024

  2. [10]

    Tenenbaum, Antonio Torralba, Florian Shkurti, and Liam Paull

    Qiao Gu, Ali Kuwajerwala, Sacha Morin, Krishna Murthy Jatavallabhula, Bipasha Sen, Aditya Agarwal, Corban Rivera, William Paul, Kirsty Ellis, Ramalingam Chellappa, Chuang Gan, Celso de Melo, Joshua B. Tenenbaum, Antonio Torralba, Florian Shkurti, and Liam Paull. 2023. https://...

    2023

  3. [11]

    Tanmay Gupta and Aniruddha Kembhavi. 2023. Visual programming: Compositional visual reasoning without training. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 14953--14962

    2023

  4. [12]

    Joy Hsu, Jiayuan Mao, and Jiajun Wu. 2023. Ns3d: Neuro-symbolic grounding of 3d objects and relations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2614--2623

    2023

  5. [13]

    Haifeng Huang, Yilun Chen, Zehan Wang, Rongjie Huang, Runsen Xu, Tai Wang, Luping Liu, Xize Cheng, Yang Zhao, Jiangmiao Pang, and 1 others. 2024. Chat-scene: Bridging 3d scene and large language models with object identifiers. Advances in Neural Information Processing Systems,...

    2024

  6. [14]

    Shijia Huang, Yilun Chen, Jiaya Jia, and Liwei Wang. 2022. Multi-view transformer for 3d visual grounding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15524--15533

    2022

  7. [15]

    Ayush Jain, Nikolaos Gkanatsios, Ishita Mediratta, and Katerina Fragkiadaki. 2022. Bottom up top down detection transformers for language grounding in images and point clouds. In European Conference on Computer Vision, pages 417--433. Springer

    2022

  8. [16]

    Baoxiong Jia, Yixin Chen, Huangyue Yu, Yan Wang, Xuesong Niu, Tengyu Liu, Qing Li, and Siyuan Huang. 2024. Sceneverse: Scaling 3d vision-language learning for grounded scene understanding. In European Conference on Computer Vision, pages 289--310. Springer

    2024

  9. [17]

    Berg, Wan-Yen Lo, Piotr Doll \'a r, and Ross B

    Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chlo \'e Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alexander C. Berg, Wan-Yen Lo, Piotr Doll \'a r, and Ross B. Girshick. 2023. https://api.semanticscholar.org/CorpusID:257952310 Segment anything . 2023 IE...

    2023

  10. [18]

    Hung Le, Yue Wang, Akhilesh Deepak Gotmare, Silvio Savarese, and Steven Chu Hong Hoi. 2022. Coderl: Mastering code generation through pretrained models and deep reinforcement learning. Advances in Neural Information Processing Systems, 35:21314--21328

    2022

  11. [19]

    Chengshu Li, Jacky Liang, Andy Zeng, Xinyun Chen, Karol Hausman, Dorsa Sadigh, Sergey Levine, Li Fei-Fei, Fei Xia, and brian ichter. 2024. https://openreview.net/forum?id=vKtomqlSxm Chain of code: Reasoning with a language model-augmented code emulator . In Forty-first Interna...

    2024

  12. [20]

    Rong Li, Shijie Li, Lingdong Kong, Xulei Yang, and Junwei Liang. 2025. Seeground: See and ground for zero-shot open-vocabulary 3d visual grounding. In Proceedings of the Computer Vision and Pattern Recognition Conference, pages 3707--3717

    2025

  13. [21]

    Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. 2023. Code as policies: Language model programs for embodied control. In 2023 IEEE International Conference on Robotics and Automation (ICRA), pages 9493--9500. IEEE

    2023

  14. [22]

    Daizong Liu, Yang Liu, Wencan Huang, and Wei Hu. 2025. A survey on text-guided 3-d visual grounding: Elements, recent advances, and future directions. IEEE Transactions on Neural Networks and Learning Systems

    2025

  15. [23]

    Shilong Liu, Zhaoyang Zeng, Tianhe Ren, Feng Li, Hao Zhang, Jie Yang, Qing Jiang, Chunyuan Li, Jianwei Yang, Hang Su, and 1 others. 2024. Grounding dino: Marrying dino with grounded pre-training for open-set object detection. In European conference on computer vision, pages 38...

    2024

  16. [24]

    Yecheng Jason Ma, William Liang, Guanzhi Wang, De-An Huang, Osbert Bastani, Dinesh Jayaraman, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2024. https://openreview.net/forum?id=IEduRUO55F Eureka: Human-level reward design via coding large language models . In The Twelfth Interna...

    2024

  17. [25]

    Locate 3d: Real-world object localization via self-supervised learning in 3d

    Paul McVay, Sergio Arnaud, Ada Martin, Arjun Majumdar, Krishna Murthy Jatavallabhula, Phillip Thomas, Ruslan Partsey, Daniel Dugas, Abha Gejji, Alexander Sax, and 1 others. Locate 3d: Real-world object localization via self-supervised learning in 3d. In Forty-second Internatio...

  18. [26]

    Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, and 1 others. 2021. Learning transferable visual models from natural language supervision. In International conference on machine...

    2021

  19. [27]

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

    2023 arXiv

  20. [28]

    Hanqing Wang, Jiahe Chen, Wensi Huang, Qingwei Ben, Tai Wang, Boyu Mi, Tao Huang, Siheng Zhao, Yilun Chen, Sizhe Yang, and 1 others. 2024. Grutopia: Dream general robots in a city at scale. arXiv preprint arXiv:2407.10943

    2024 arXiv

  21. [29]

    Changli Wu, Jiayi Ji, Haowei Wang, Yiwei Ma, You Huang, Gen Luo, Hao Fei, Xiaoshuai Sun, Rongrong Ji, and 1 others. 2025 a . Rg-san: Rule-guided spatial awareness network for end-to-end 3d referring expression segmentation. Advances in Neural Information Processing Systems, 37...

    2025

  22. [30]

    Yangzhen Wu, Zhiqing Sun, Shanda Li, Sean Welleck, and Yiming Yang. 2025 b . https://openreview.net/forum?id=VNckp7JEHn Inference scaling laws: An empirical analysis of compute-optimal inference for LLM problem-solving . In The Thirteenth International Conference on Learning R...

    2025

  23. [31]

    Yanmin Wu, Xinhua Cheng, Renrui Zhang, Zesen Cheng, and Jian Zhang. 2023. Eda: Explicit text-decoupling and dense alignment for 3d visual grounding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 19231--19242

    2023

  24. [32]

    Runsen Xu, Zhiwei Huang, Tai Wang, Yilun Chen, Jiangmiao Pang, and Dahua Lin. 2024. Vlm-grounder: A vlm agent for zero-shot 3d visual grounding. In 8th Annual Conference on Robot Learning

    2024

  25. [33]

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, and 43 others. 2024 a . https://arxiv.org...

    2024 arXiv

  26. [34]

    Jianing Yang, Xuweiyi Chen, Shengyi Qian, Nikhil Madaan, Madhavan Iyengar, David F Fouhey, and Joyce Chai. 2024 b . Llm-grounder: Open-vocabulary 3d visual grounding with large language model as an agent. In 2024 IEEE International Conference on Robotics and Automation (ICRA),...

    2024

  27. [35]

    Zhengyuan Yang, Songyang Zhang, Liwei Wang, and Jiebo Luo. 2021. Sat: 2d semantics assisted training for 3d visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1856--1866

    2021

  28. [36]

    Qihao Yuan, Jiaming Zhang, Kailai Li, and Rainer Stiefelhagen. 2024 a . Solving zero-shot 3d visual grounding as constraint satisfaction problems. arXiv preprint arXiv:2411.14594

    2024 arXiv

  29. [37]

    Zhihao Yuan, Jinke Ren, Chun-Mei Feng, Hengshuang Zhao, Shuguang Cui, and Zhen Li. 2024 b . Visual programming for zero-shot open-vocabulary 3d visual grounding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 20623--20633

    2024

  30. [38]

    Zhihao Yuan, Xu Yan, Yinghong Liao, Ruimao Zhang, Sheng Wang, Zhen Li, and Shuguang Cui. 2021. Instancerefer: Cooperative holistic understanding for visual grounding on point clouds through instance multi-level contextual referring. In Proceedings of the IEEE/CVF International...

    2021

  31. [39]

    Nader Zantout, Haochen Zhang, Pujith Kachana, Jinkai Qiu, Ji Zhang, and Wenshan Wang. 2025. https://arxiv.org/abs/2504.18684 Sort3d: Spatial object-centric reasoning toolbox for zero-shot 3d grounding using large language models . Preprint, arXiv:2504.18684

    2025 arXiv

  32. [40]

    Fan Zhou, Zengzhi Wang, Qian Liu, Junlong Li, and Pengfei Liu. 2025. https://openreview.net/forum?id=ak0vlKTkpx Programming every example: Lifting pre-training data quality like experts at scale . In Forty-second International Conference on Machine Learning

    2025

  33. [41]

    Ziyu Zhu, Xiaojian Ma, Yixin Chen, Zhidong Deng, Siyuan Huang, and Qing Li. 2023. 3d-vista: Pre-trained transformer for 3d vision and text alignment. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2911--2921

    2023

  34. [42]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  35. [43]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

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