Pith. sign in

REVIEW 3 major objections 4 minor 41 references

DEMONSTRATE: Zero-shot Language to Robotic Control via Multi-task Demonstration Learning

T0 review · 3 major / 4 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 A learned map from task descriptions to control costs lets robots execute new commands from demonstrations, matching or beating LLM-based baselines.

desk verdict A clever demonstration-driven alternative to LLM prompt engineering for MPC, with a genuinely useful validation idea, but the gate's calibration is unproven and the baseline comparison is inherited. read the letter →

arxiv 2507.12855 v1 pith:EKYHIL5N submitted 2025-07-17 cs.RO cs.SYeess.SY

Rahel Rickenbach , Bruce Lee , René Zurbrügg , Carmen Amo Alonso , Melanie N. Zeilinger This is my paper
classification cs.ROcs.SYeess.SY
keywords language-conditionedcontrolinverseoptimalmulti-taskrepresentationlearningmodelpredictivehallucinationdetectionfromdemonstrationszero-shotgeneralizationroboticmanipulation
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 a robotic controller can be specified by natural language without an LLM writing the underlying math: instead, demonstrations of sub-tasks teach a parametric map from compressed sentence embeddings to the cost weights of a model predictive control problem. The map is learned with inverse optimal control, and all tasks are constrained to share the same cost-feature and constraint templates, so a new spoken command within the same task family is executed zero-shot. A coverage-based validation step rejects commands whose embeddings are too far from the demonstrations, giving a pre-execution hallucination check that LLM-based controllers lack. In tabletop pick-and-place experiments, the authors report success rates comparable to or higher than the best baseline in all four tasks, with the acknowledged tradeoff that commands far from the demonstrations are refused or fail.

What carries the argument

The load-bearing object is a shared, parameterized optimal-control template: cost features $\varphi(x,u,m)$ and constraint functions $g(x,u,\rho)$ are common across all tasks, while task identity lives entirely in the weight vector $\theta$ predicted by the map $M$. Learning uses the maximum-entropy inverse optimal control likelihood from locally optimal demonstrations, approximated by gradients and Hessians of the cost, to fit $M$ and the shared parameter $m$ jointly; constraint parameter $\rho$ is fit from safe and unsafe demonstrations with a satisfiability-modulo-convex program. The online sub-task validation uses the coverage coefficient of the target embedding against the span of demonstration embeddings to decide whether to re-plan or refuse execution.

What would settle it

In a task family where the true cost weights are known, hold out several commands, run the offline learning on demonstrations of the rest, and compare the predicted $\theta$ from the parametric map with the true $\theta$: if the coverage test passes and the predicted weights yield trajectories that clearly fail the known objective, the central claim that the embedding-to-weight map is sufficient is wrong. Similarly, a command semantically inside the family whose embedding lands outside the demonstration span would show that the validation check is not a faithful hallucination test.

Watch

Extended reading notes

Core claim

The central claim is that, for any task family whose costs and constraints share the parameterized form $c_t(x,u)=\theta_t^\top \varphi(x,u,m)$ and $g(x,u,\rho)\le 0$ with shared $m,\rho$, a map $M$ from PCA-compressed language embeddings $\tilde{e}_t$ to task-specific cost weights $\theta_t$ can be learned jointly with $m$ from suboptimal demonstrations via an entropy-maximization inverse optimal control objective. Constraints are estimated separately from demonstrations that avoid an unsafe region, using satisfiability-modulo-convex programming. Because $\theta_t$ is produced by the map from the embedding rather than by LLM code generation, outputs are guaranteed to lie in the pre-defined task feature space, and the coverage test of Eq. (3) measures whether a planned sub-task is close enough to the demonstration set before execution. The paper reports comparable or higher success rates than the best baseline in all four simulated tasks and demonstrates hardware execution of stacking, L-shape, and pyramid tasks.

Load-bearing premise

The load-bearing premise is that every task, demonstrated or commanded, fits the same cost and constraint template and differs only in a small set of task weights; command a task outside that family and the learned map has nothing valid to output.

Editorial extensions

If this is right

  • A user can issue new commands in the trained task family without an engineer writing symbolic costs or constraints; only demonstrations and language descriptions are needed.
  • The LLM's role is reduced to task decomposition and embedding, so failures shift from malformed code to the learned map, and the coverage check can catch out-of-family sub-tasks before execution.
  • Because the map is learned from a few demonstrations per sub-task (20 demonstrations for 90 sub-tasks in the experiments), the approach is practical for tabletop manipulation and likely scales with more demonstration data.
  • The reported success rates on the benchmark tasks are comparable to or higher than the best baseline in the paper's comparison, while far-from-demonstration commands are deliberately refused; the demonstrated design goal is reliability within a task family rather than open-ended generalization.

Reading between the lines

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

  • A testable consequence the authors do not pursue: the same shared template could support multiple task families if $m$ and $\rho$ were learned once per family and composed, effectively making the pre-implemented feature library the true scope of the method.
  • Because validation operates on embeddings, commands that are semantically different but embedded nearby, or paraphrases with different numbers, might pass or fail the coverage test in ways unrelated to control feasibility; separating numeric from semantic content, as the conclusion suggests, could be evaluated directly.
  • If human demonstration datasets were used to train the map, the method could scale beyond the proof-of-concept simulation demonstrations; the paper lists this as future work, but it is a natural next experiment given the pipeline's reliance on demonstrations rather than on prompt engineering.
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

3 major / 4 minor

Summary. The paper proposes DEMONSTRATE, a pipeline that maps natural-language task descriptions to optimal control problems (OCP) without requiring an LLM to generate cost or constraint expressions. The cost function is represented as a feature vector θ multiplied by shared feature functions φ(x,u,m), and constraints as shared templates g(x,u,ρ)≤0. The core idea is to learn, offline, a parametric mapping M from compressed sentence embeddings of sub-task descriptions to θ, using maximum-entropy inverse optimal control on demonstrations, under Assumption 1 that all tasks share m and ρ. Online, a task planner breaks a user command into sub-tasks, each embedding is checked against a coverage threshold (Eq. 3) to assess similarity to the demonstrations, and the learned M produces θ, which is used in an MPC. The paper reports simulation and hardware experiments on tabletop manipulation (stacking cubes, writing L, building a pyramid, wiping a pan) and compares against NARRATE, VoxPoser, and Code-as-Policies. The central claims are zero-shot generalization to new tasks and the ability to assess hallucinations before execution.

Significance. The work addresses a real bottleneck in LLM-based control: the need for expert-engineered in-context examples and the lack of pre-execution hallucination checks. The proposed combination of inverse optimal control with mult-task representation learning is a sensible and potentially practical direction. The paper is transparent about the experimental protocol, ships code and videos, and the optimization in Eq. (5) is a clean multi-task extension of maximum-entropy IOC. If the hallucination-gating mechanism were properly calibrated and the scope of the multitask assumption were validated, the method could be a useful contribution. However, as presented, the load-bearing claims about generalization and pre-execution hallucination assessment are not fully supported by the evidence.

major comments (3)
  1. [§IV.A.1.a, Assumption 1] Assumption 1 restricts all tasks to share the feature parameters m and ρ, with task specificity only through θ. This means the method can only represent tasks whose cost features and constraint templates are identical up to a cost-weight vector. The experiments exclusively consider relative pick-and-place sub-tasks (translations and rotations), which trivially satisfy this homogeneity. The conclusion (Section VII) nevertheless claims execution of 'a diverse array of tasks.' This overstates the validated scope. If a target task requires a different constraint type or cost feature structure, the method cannot represent it at all, regardless of embedding similarity. The paper should either demonstrate a broader class of task families or explicitly limit the claim to the tested pick-and-place setting.
  2. [§IV.B.1.b, Eq. (3) and §VI.D] The sub-task validation gate is the primary mechanism for the paper's core claim of hallucination assessment before execution, but the threshold t is a hand-picked constant (3.0) with no sensitivity analysis, no calibration against downstream success, and no statistical characterization. More fundamentally, the coverage coefficient is computed in the embedding space, whereas the actual validity of the OCP depends on θ = M(q, e) produced by the MLP. The paper provides no Lipschitz or regularity guarantee for M, so two embeddings that are close in PCA-reduced space need not yield similar θ, and a small coverage residual does not imply a valid or safe OCP. The footnote in Section V.A/B implicitly acknowledges this gap by noting that the theoretical motivation from [35] does not directly apply because θ is a neural-network output. The evidence for the gate consists of three hand-picked examples (Fig. 2) and one extrapolation study (Table II). This is insufficient to support the pre-execution hallucination-assessment claim. The authors should provide either a theoretical bound relating embedding coverage to θ-validity or an empirical calibration study showing that gate accept/reject decisions track downstream task success.
  3. [§VI.C, Table I] The statement 'DEMONSTRATE shows comparable or higher success rates than the best performing base line model in all 4 tasks' is contradicted by the data in Table I for the Stack task: DEMONSTRATE achieves 88% success vs. CaP's 98%. The claim should be corrected to reflect the actual comparisons. Additionally, the baseline numbers are taken from the prior NARRATE paper rather than re-run in the same environment, and no confidence intervals or significance tests are reported. Given that the difference between 88% and 98% could be within statistical noise for 50 runs, the claim of 'comparable or higher' requires at least error bars or a significance test.
minor comments (4)
  1. [Eq. (5) and surrounding text] In the line before Eq. (5), the optimization variables q and m are missing the estimated notation (hat) used elsewhere; similarly, the left-hand side of Eq. (5) omits the hat. Please make the notation consistent.
  2. [Eq. (1b)] The dynamics constraint is written with indices i=1,...,N, but with x0 given, the natural range should be i=0,...,N-1 to cover all state transitions. The same index inconsistency appears in Eq. (6b) (k=1,...,N-1 vs. k=0,...,N-1 in the reformulated SMC problem).
  3. [Section II and references] The sentence-transformer model 'all-mpnet-base-v2' is cited to [34] (the MPNet paper), but the sentence-transformers library is more directly associated with [33] (Sentence-BERT). It would be clearer to cite the actual model card or the SBERT framework.
  4. [Section VI.F] The hardware experiments are described only qualitatively with a figure and video references; reporting success rates or per-trial outcomes for the hardware runs would strengthen the reproducibility claims.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the main language-to-cost mapping is fitted to demonstrations and evaluated on external task success; the sole self-citation [35] motivates a screening heuristic rather than encoding the predicted outcome.

full rationale

The derivation chain in DEMONSTRATE is: demonstrations of example sub-tasks are used with inverse optimal control to jointly estimate the shared cost parameter m and the parametric map M from compressed embeddings to cost weights θ (Eq. 5); at test time, a new language sub-task is embedded, optionally validated by the coverage check in Eq. (3), and passed through M to obtain θ for the OCP; success is then measured externally by task completion (Table I). The learned map is fitted to demonstrations, but the target-task predictions are evaluated against an external success metric, not against the training objective or a quantity constructed from the demonstrations. Thus the central 'prediction' (the cost weight θ and the resulting executed trajectory) is not statistically forced by the fit in the sense of fitted-input-called-prediction. Assumption 1 (shared m and ρ across tasks, with task-specificity only through θ) does make 'target and example task similarity' hold by construction, but this is an explicitly stated domain restriction rather than a hidden equivalence between input and output; it limits generalization claims but does not reduce the derivation to its inputs. The sub-task validation in Eq. (3) is motivated by a self-citation ([35], by co-author Bruce Lee), and the threshold t = 3.0 is user-defined and uncalibrated. However, the paper does not claim that Eq. (3) is equivalent to downstream success; it is presented as a screening heuristic, and the experimental benchmarking relies on externally defined task success rather than on the coverage coefficient. The lack of calibration of t and the absence of a demonstrated link between coverage residual and OCP validity are correctness/validation gaps, not circularity. The conclusion's limitation statement explicitly acknowledges poor zero-shot generalization to tasks far from the demonstrations, further indicating that the empirical claims are not being enforced by construction. Overall, no enumerated circularity pattern is exhibited; the paper is self-contained against external baselines (NARRATE, VoxPoser, Code as Policies), so the appropriate score is low.

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

The ledger shows that the method rests on a stated task-space homogeneity assumption, a near-optimality assumption on demonstrations, and an unexamined alignment between embedding geometry and control-task geometry. Several experimental hyperparameters (threshold, PCA dimension, demonstration count, feature templates) are hand-selected; these are not fitted to the target results but affect the reported success rates.

free parameters (4)
  • Sub-task validation threshold t = 3.0
    User-defined threshold in Eq (3); set to 3.0 for all experiments. Controls how aggressively the system rejects novel sub-tasks; no data-driven selection.
  • Number of PCA components z = 20
    Embeddings compressed to 20 principal components; chosen by hand. The paper does not justify this dimension.
  • Demonstration count per sub-task D = 20
    Each of the 90 sub-tasks is trained with 20 simulated demonstrations; the paper calls this 'few' but provides no scaling study.
  • Cost feature functions phi and constraint templates g
    The multitask structure in Eq (2) requires the user to pre-implement these functions; this retains an engineering-design step that the paper claims to remove.
assumptions (4)
  • domain assumption All demonstration and target tasks share the same parameter vectors m and rho; only theta varies (Assumption 1, Sec IV.A.1.a).
    This permits a single shared cost and constraint structure, but restricts the method to task families that are homogeneous in these parameters.
  • domain assumption Demonstrations are near-optimal for the underlying cost c in class (2).
    Stated in Sec IV.A.1.b, following [29]. If demonstrations are far from optimal, the maximum-entropy IOC estimate is biased.
  • domain assumption Embedding distance reflects task similarity in control space.
    Used to train M and to validate sub-tasks (Eq 3). No evidence that embedding geometry aligns with the learned task feature space.
  • standard math Maximum-entropy IOC approximation of [29] holds.
    The parameter estimation in Eq (5) uses the Laplace approximation from Levine and Koltun; correctness depends on their result.

how reviews work

0 comments
Cite this review

Pith. "Pith review of DEMONSTRATE: Zero-shot Language to Robotic Control via Multi-task Demonstration Learning." pith.science (2026). https://pith.science/paper/EKYHIL5N

@misc{pith2026250712855,
  author       = {Pith},
  title        = {Pith review of: DEMONSTRATE: Zero-shot Language to Robotic Control via Multi-task Demonstration Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EKYHIL5N}},
  note         = {Machine review of arXiv:2507.12855}
}
read the original abstract

The integration of large language models (LLMs) with control systems has demonstrated significant potential in various settings, such as task completion with a robotic manipulator. A main reason for this success is the ability of LLMs to perform in-context learning, which, however, strongly relies on the design of task examples, closely related to the target tasks. Consequently, employing LLMs to formulate optimal control problems often requires task examples that contain explicit mathematical expressions, designed by trained engineers. Furthermore, there is often no principled way to evaluate for hallucination before task execution. To address these challenges, we propose DEMONSTRATE, a novel methodology that avoids the use of LLMs for complex optimization problem generations, and instead only relies on the embedding representations of task descriptions. To do this, we leverage tools from inverse optimal control to replace in-context prompt examples with task demonstrations, as well as the concept of multitask learning, which ensures target and example task similarity by construction. Given the fact that hardware demonstrations can easily be collected using teleoperation or guidance of the robot, our approach significantly reduces the reliance on engineering expertise for designing in-context examples. Furthermore, the enforced multitask structure enables learning from few demonstrations and assessment of hallucinations prior to task execution. We demonstrate the effectiveness of our method through simulation and hardware experiments involving a robotic arm tasked with tabletop manipulation.

Figures

Figures reproduced from arXiv: 2507.12855 by the authors.

Figure 1
Figure 1. A. Offline pipeline: (a) A user provides sub-task descriptions together with trajectory demonstrations; (b) the LLM computes the embedding vectors for the sub-task descriptions; (c) the demonstrations and the embedding vectors are used to learn (i) a parametric mapping, and (ii) the multitask parameters, both used in the online pipeline. B. Online pipeline: Architecture of [11], with an added SV Module and modified … view at source ↗
Figure 2
Figure 2. Examples of sub-task validation using the [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 4
Figure 4. Illustration of considered en￾vironments in simulation and real￾world experiments. “Open the Drawer ” +“5cm” +“10cm” +“15cm” Result (cm) 5.8 8.9 Cannot perform TABLE II: Limits: We test the distances which the drawer can be opened via the command “Open the drawer ” finished by either “5cm”, “10cm”, or “15cm”. We then show the resulting final position for the drawer. to the side of an object. The results on the drawe… view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

41 extracted references · 24 canonical work pages

  1. [11]

    Narrate: Versatile language architecture for optimal control in robotics,

    S. Ismail, A. Arbues et al. , “Narrate: Versatile language architecture for optimal control in robotics,” in Int. Conf. Intel. Robots Syst. (IROS). IEEE, 2024, pp. 9628–9635

    work page 2024

  2. [35]

    Guarantees for nonlinear representation learning: non-identical covariates, dependent data, fewer samples,

    T. T. Zhang, B. D. Lee et al., “Guarantees for nonlinear representation learning: non-identical covariates, dependent data, fewer samples,” arXiv:2410.11227, 2024

    arXiv 2024

  3. [1]

    Prompt a robot to walk with large language models,

    Y .-J. Wang, B. Zhang, J. Chen, and K. Sreenath, “Prompt a robot to walk with large language models,” arXiv:2309.09969, 2023

    arXiv 2023

  4. [2]

    Vima: General robot manipulation with multimodal prompts,

    Y . Jiang, A. Gupta et al. , “Vima: General robot manipulation with multimodal prompts,” arXiv:2210.03094, 2022

    arXiv 2022

  5. [3]

    Perceiver-actor: A multi-task transformer for robotic manipulation,

    M. Shridhar, L. Manuelli, and D. Fox, “Perceiver-actor: A multi-task transformer for robotic manipulation,” in Conf. on Robot Learning , 2022

    work page 2022

  6. [4]

    Roco: Dialectic multi-robot collab- oration with large language models,

    Z. Mandi, S. Jain, and S. Song, “Roco: Dialectic multi-robot collab- oration with large language models,” arXiv:2307.04738, 2023

    arXiv 2023

  7. [5]

    Program synthesis with large language models,

    J. Austin, A. Odena et al. , “Program synthesis with large language models,” arXiv:2108.07732, 2021

    arXiv 2021

  8. [6]

    Learning to synthesize programs as interpretable and generalizable policies,

    D. Trivedi, J. Zhang et al. , “Learning to synthesize programs as interpretable and generalizable policies,” Adv. Neural Inf. Process. Syst., vol. 34, pp. 25 146–25 163, 2021

    work page 2021

Show all 41 references
  1. [7]

    Code as policies: Language model programs for embodied control,

    J. Liang, W. Huang et al. , “Code as policies: Language model programs for embodied control,” in IEEE Int. Conf. on Robot. and Automat. (ICRA). IEEE, 2023, pp. 9493–9500

    2023

  2. [8]

    Using natural language for reward shaping in reinforcement learning,

    P. Goyal, S. Niekum, and R. J. Mooney, “Using natural language for reward shaping in reinforcement learning,” arXiv:1903.02020, 2019

    1903 arXiv

  3. [9]

    Language to rewards for robotic skill synthesis,

    W. Yu, N. Gileadi et al. , “Language to rewards for robotic skill synthesis,” arXiv:2306.08647, 2023

    2023 arXiv

  4. [10]

    Eureka: Human-level reward design via coding large language models,

    Y . J. Ma, W. Liang et al. , “Eureka: Human-level reward design via coding large language models,” arXiv:2310.12931, 2023

    2023 arXiv

  5. [12]

    A survey of inverse reinforcement learning,

    S. Arora and P. Doshi, “A survey of inverse reinforcement learning,” Artif. Intell., 2021

    2021

  6. [13]

    The benefit of mul- titask representation learning,

    A. Maurer, M. Pontil, and B. Romera-Paredes, “The benefit of mul- titask representation learning,” J. Mach. Learn. Res. , vol. 17, no. 81, pp. 1–32, 2016

    2016

  7. [14]

    A survey on multi-task learning,

    Y . Zhang and Q. Yang, “A survey on multi-task learning,” IEEE Trans. Knowl. Data Eng. , vol. 34, no. 12, pp. 5586–5609, 2022

    2022

  8. [15]

    Context-aware llm-based safe control against latent risks,

    Q. K. Luu, X. Deng et al. , “Context-aware llm-based safe control against latent risks,” arXiv:2403.11863, 2024

    2024 arXiv

  9. [16]

    Affordance-guided reinforcement learning via visual prompting,

    O. Y . Lee, A. Xie et al. , “Affordance-guided reinforcement learning via visual prompting,” arXiv:2407.10341, 2024

    2024 arXiv

  10. [17]

    Language models are few-shot learners,

    T. Brown, B. Mann et al., “Language models are few-shot learners,” Adv. Neural Inf. Proc. Syst. , vol. 33, pp. 1877–1901, 2020

    1901

  11. [18]

    A survey of controllable text generation us- ing transformer-based pre-trained language models,

    H. Zhang, H. Song et al., “A survey of controllable text generation us- ing transformer-based pre-trained language models,” ACM Computing Surveys, vol. 56, no. 3, pp. 1–37, 2023

    2023

  12. [19]

    How can we know what language models know?

    Z. Jiang, F. F. Xu et al. , “How can we know what language models know?” Trans. Assoc. Comput. Linguistics, vol. 8, pp. 423–438, 2020

    2020

  13. [20]

    Autoprompt: Eliciting knowledge from language models with automatically generated prompts,

    T. Shin, Y . Razeghi et al. , “Autoprompt: Eliciting knowledge from language models with automatically generated prompts,” arXiv:2010.15980, 2020

    2010 arXiv

  14. [21]

    Universal and transferable adversarial attacks on aligned language models,

    A. Zou, Z. Wang et al., “Universal and transferable adversarial attacks on aligned language models,” arXiv:2307.15043, 2023

    2023 arXiv

  15. [22]

    Rlprompt: Optimizing discrete text prompts with reinforcement learning,

    M. Deng, J. Wang et al., “Rlprompt: Optimizing discrete text prompts with reinforcement learning,” arXiv:2205.12548, 2022

    2022 arXiv

  16. [23]

    Tempera: Test-time prompting via rein- forcement learning,

    T. Zhang, X. Wang et al. , “Tempera: Test-time prompting via rein- forcement learning,” arXiv:2211.11890, 2022

    2022 arXiv

  17. [24]

    Prompt programming for large lan- guage models: Beyond the few-shot paradigm,

    L. Reynolds and K. McDonell, “Prompt programming for large lan- guage models: Beyond the few-shot paradigm,” in Extended abstracts of the 2021 CHI conference on human factors in computing systems , 2021, pp. 1–7

    2021

  18. [25]

    Clara: Classifying and disambiguating user commands for reliable interactive robotic agents,

    J. Park, S. Lim et al. , “Clara: Classifying and disambiguating user commands for reliable interactive robotic agents,” IEEE Robot. Au- tomat. Lett., vol. 9, no. 2, pp. 1059–1066, 2024

    2024

  19. [26]

    Robots that ask for help: Uncertainty alignment for large language model planners,

    A. Z. Ren, A. Dixit, A. Bodrova, S. Singh, S. Tu, N. Brown, P. Xu, L. Takayama, F. Xia, J. Varley, Z. Xu, D. Sadigh, A. Zeng, and A. Majumdar, “Robots that ask for help: Uncertainty alignment for large language model planners,” 2023

    2023

  20. [27]

    Model predictive control,

    B. Kouvaritakis and M. Cannon, “Model predictive control,” Switzer- land: Springer Int. Publishing , 2016

    2016

  21. [28]

    Maximum entropy inverse rein- forcement learning,

    B. D. Ziebart, A. L. Maas et al. , “Maximum entropy inverse rein- forcement learning,” in Conf. Artif. Intel., vol. 8. Chicago, IL, USA, 2008, pp. 1433–1438

    2008

  22. [29]

    Continuous inverse optimal control with locally optimal examples,

    S. Levine and V . Koltun, “Continuous inverse optimal control with locally optimal examples,” in Proc. Int. Conf. Mach. Learn. , 2012, pp. 475–482

    2012

  23. [30]

    Learning constraints from demonstrations,

    G. Chou, D. Berenson, and N. Ozay, “Learning constraints from demonstrations,” in Algorithmic Found. of Robot. XIII . Springer, 2020, pp. 228–245

    2020

  24. [31]

    Learning parametric constraints in high dimensions from demonstrations,

    G. Chou, N. Ozay, and D. Berenson, “Learning parametric constraints in high dimensions from demonstrations,” in Conf. Robot Learn. PMLR, 2020, pp. 1211–1230

    2020

  25. [32]

    Sparse spectrum gaussian process regression,

    M. L ´azaro-Gredilla, J. Quinonero-Candela et al. , “Sparse spectrum gaussian process regression,” J. Mach. Learn. Res., vol. 11, pp. 1865– 1881, 2010

    2010

  26. [33]

    Sentence-bert: Sentence embeddings using siamese bert-networks,

    N. Reimers and I. Gurevych, “Sentence-bert: Sentence embeddings using siamese bert-networks,” in Proc Conf. Empirical Methods in Natural Language Processing . Association for Computational Lin- guistics, 11 2019

    2019

  27. [34]

    Mpnet: Masked and permuted pre-training for language understanding,

    K. Song, X. Tan et al. , “Mpnet: Masked and permuted pre-training for language understanding,” Adv. Neural Inf. Process. Syst. , vol. 33, pp. 16 857–16 867, 2020

    2020

  28. [36]

    Smc: Satisfiability modulo convex optimization,

    Y . Shoukry, P. Nuzzo, A. L. Sangiovanni-Vincentelli, S. A. Seshia, G. J. Pappas, and P. Tabuada, “Smc: Satisfiability modulo convex optimization,” in Proceedings of the 20th international conference on hybrid systems: Computation and control , 2017, pp. 19–28

    2017

  29. [37]

    CasADi – A software framework for nonlinear optimization and optimal control,

    J. A. E. Andersson, J. Gillis, G. Horn, J. B. Rawlings, and M. Diehl, “CasADi – A software framework for nonlinear optimization and optimal control,” Mathematical Programming Computation , 2019

    2019

  30. [38]

    do-mpc: Towards fair nonlinear and robust model predictive control,

    F. Fiedler, B. Karg, L. L ¨uken, D. Brandner, M. Heinlein, F. Brabender, and S. Lucia, “do-mpc: Towards fair nonlinear and robust model predictive control,” Control Engineering Practice , 2023

    2023

  31. [39]

    panda-gym: Open-source goal- conditioned environments for robotic learning,

    Q. Gallou ´edec, N. Cazin et al. , “panda-gym: Open-source goal- conditioned environments for robotic learning,” arXiv:2106.13687, 2021

    2021 arXiv

  32. [40]

    V oxposer: Composable 3d value maps for robotic manipulation with language models,

    W. Huang, C. Wang et al., “V oxposer: Composable 3d value maps for robotic manipulation with language models,” arXiv:2307.05973, 2023

    2023 arXiv

  33. [41]

    Open x-embodiment: Robotic learning datasets and rt-x models: Open x- embodiment collaboration 0,

    A. O’Neill, A. Rehman, A. Maddukuri, A. Gupta, A. Padalkar, A. Lee, A. Pooley, A. Gupta, A. Mandlekar, A. Jain et al. , “Open x-embodiment: Robotic learning datasets and rt-x models: Open x- embodiment collaboration 0,” in Int. Conf. Robot. Automation (ICRA). IEEE, 2024, pp. 6892–6903

    2024

Pith tools

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