PaperlayerView exact revision on arXiv

Source-linked AI summary

Macro-Operator Generation and Predicate Selection for TAMP Operator Learning

Can Emir Bora, Emre Ugur

arXiv:2608.23629v1cs.ROcs.AI

TL;DR

Learned TAMP operators still leave long-horizon search burdened by recurring action sequences and predicates unused by any operator. The paper generates causal macro-operators and prunes unused predicates, achieving up to ∼4.6× speedup across four domains and solving a task the baseline cannot solve. The approach is currently limited to action pairs and simulation-based experiments.

  • Problem

    Existing learned TAMP methods treat actions individually and evaluate unused predicates at every search node, leaving long-horizon planning and symbolic-state evaluation inefficient.

  • Method

    The system discovers causally linked action pairs from training data as macro-operators and applies Iterative Predicate Selection to remove predicates absent from learned preconditions and effects.

  • Results

    Across four TAMP domains, the method achieves up to ∼4.6× planning speedup and solves Kitchen, where the baseline finds no plan even without a time limit.

  • Takeaways & Limitations

    Macro-operators shorten the effective planning horizon, with their practical value increasing for longer tasks and determining solvability in some domains.

  • Takeaways & Limitations

    The current pipeline considers only pairs of consecutive actions, cannot create new predicates, uses hand-designed continuous samplers, and has been evaluated only in PyBullet simulation.

Abstract

from arXiv · show

Creating symbolic operators by hand is one of the main bottlenecks in deploying Task and Motion Planning systems (TAMP). Recent works show that these operators can instead be learned directly from demonstration data. Existing methods, however, typically learn each action in isolation and cannot capture the recurring multi-step structure of manipulation tasks, so the search becomes intractable on long sequential tasks. A further inefficiency arises in the symbolic state: every provided predicate is evaluated at every search node, even when it never appears in any learned operator. We present a system that addresses both problems together. Its central component is the automatic generation of macro-operators, composite actions that compress a recurring sequence of individual actions into a single planning step. Our system discovers causally linked action pairs directly from the training data, where one action produces exactly the condition that the next one requires, and turns each pair into a new operator. Alongside this, our system prunes every predicate that no learned operator references, which shrinks the symbolic state evaluated at each search node. Together, these changes shorten the effective planning horizon, and the benefit they bring grows with the length of the task. Across four TAMP domains, our method reaches up to a 4.6x planning speedup compared to the baseline method, namely Learning Operators for TAMP. More importantly, it solves a long sequential task that the baseline cannot solve. Macro-operator discovery thus not only accelerates planning but, in certain domains, determines solvability in practice.

I. INTRODUCTION

The paper targets two practical barriers in learned TAMP: manually specified operators, and inefficient long-horizon search with isolated actions and unused predicates. It introduces macro-operators and predicate selection, evaluating them across four domains.

  • TAMP couples symbolic action sequencing with continuous decisions such as grasp poses, trajectories, and placement locations.
  • Learned operators reduce manual specification burden, but LOFT still treats individual actions in isolation and evaluates every provided predicate at every search node.
  • Macro-operators replace causally linked action pairs with composite actions, shrinking the effective planning horizon and slowing branching-factor growth on long tasks.
  • Iterative Predicate Selection removes predicates absent from all learned preconditions and effects, shrinking the symbolic state parsed at each search node.
  • The evaluation covers four TAMP domains, including Kitchen, where seven ingredients must each be picked, chopped, cooked, and plated.
  • ∼4.6× planning speedup is achieved, and Kitchen becomes solvable although the baseline finds no plan even without a planning time limit.

II. RELATED WORK

TAMP research spans formulations that jointly optimize discrete and continuous decisions, as well as approaches that structure their interaction during planning.

  • One TAMP family formulates planning as a single optimization problem over hybrid trajectories combining discrete choices and continuous motion.

B. LEARNING FOR TAMP AND OPERATOR DISCOVERY

Prior TAMP work learns continuous samplers, search guidance, symbolic operators, and sometimes predicates themselves. Macro-actions provide related abstraction, but automatic discovery for learned probabilistic TAMP operators remains underexplored.

  • Geometric learning methods propose grasp poses or placement locations, while symbolic guidance methods score relational states to steer search.
  • Model-based approaches learn operator preconditions and effects, including noisy deictic rules, LOCM, STRIPS-style models, and sparse relational transition models.
  • Some recent methods discover predicates from robot interaction by mapping continuous observations to discrete symbols and extracting relational operators.
  • Classical macro-operators and robotic macro-actions compress repeated action sequences into reusable planning steps or skills.
  • Automatic discovery and validation of macros for learned probabilistic TAMP operators remain underexplored.

III. METHOD

The pipeline learns symbolic operators from transition data, generates executable plans through symbolic search, and connects training data to planning through the proposed architecture.

  • The full pipeline maps training data to an executable plan, with the paper’s contributions highlighted as distinct stages.
  • At the high level, a PDDL-based symbolic planner uses A* search and a goal-distance heuristic to produce candidate plan skeletons.
  • LOFT learns operators from low-level transitions and fixed typed predicates by clustering lifted effects, learning preconditions, and estimating probabilistic outcomes.
  • Effects below a probability threshold are discarded, and retained outcomes are converted into deterministic operators through all-outcome determinization.

1) Macro-Operator Generation

The system discovers causally linked action pairs from training trajectories, validates them, and converts verified pairs into executable macro-operator types that compress recurring two-step patterns.

  • Discovery: Effect-complement analysis identifies ordered action pairs where one action consistently adds a predicate that the next consistently deletes.A non-empty intersection Adds[a_i] ∩ Dels[a_i+1] indicates that the first action creates a condition consumed by the second.
  • Discovery: Consistent effects are estimated from oracle demonstrations by counting predicates added or deleted across transitions for each action type.Random exploration is excluded from this phase because failed actions would dilute reliable effects.
  • Validation: Candidate causal pairs are validated by consecutive occurrences in oracle and random-exploration trajectories, retaining only pairs observed at least once.When both action orders occur, the higher-frequency direction is kept to avoid duplicate macros and inflated branching.
  • Construction: Argument unification merges the two sub-actions’ argument lists while storing index vectors that recover each sub-action’s original arguments.For Pick(b1) followed by Stack(b1, b2), the macro uses (b1, b2), with index vectors mapping arguments back to Pick and Stack.
  • Construction: Each verified pair yields positive macro transitions that skip the intermediate state, making the sequence appear as one transition from the initial to final state.The same pair can produce multiple macros when shared-object patterns differ across occurrences.
  • Construction: Generated macros initially contain only typed argument lists and positive transitions, lacking learned preconditions, effects, continuous samplers, and execution procedures.The next integration stage supplies these components through the operator-learning module.

2) Integrating Macros into the Operator Learning Module

Generated macros are integrated into the ordinary operator-learning pipeline with positive and synthetic negative transitions, while sequential sampling preserves dependencies between their sub-actions’ continuous parameters.

  • Learning: Positive macro examples come from transitions where the macro’s effect occurred, while negative examples come from states where it did not.Phase 4 supplies T+, and synthetic negatives complete the data required for accurate precondition learning.
  • Learning: Synthetic negatives are created by applying each macro to random states and recording unchanged transitions as evidence that its preconditions were not satisfied.For a macro M(o), the transition (x, M(o), x) forms part of T−.
  • Learning: Macro learning reuses the ordinary action-learning module by augmenting action types, demonstrations, and random-exploration transitions with macro counterparts.The augmented sets are A′ = A ∪ A_M, D′ = D ∪ T+, and R′ = R ∪ T−.
  • Sampling: Sequential continuous sampling generates parameters for the two sub-actions in order rather than independently.This respects dependencies such as a placement location depending on the first sub-action’s grasp pose.

3) Iterative Predicate Selection (IPS)

Iterative Predicate Selection removes symbolic predicates unused by learned operators, reducing the state representation repeatedly parsed during search without changing the operators.

  • Motivation: Every predicate is evaluated at every expanded search node, even though the user must choose the predicate set before learning reveals which predicates matter.This repeatedly incurs parsing cost during planning.
  • Motivation: Unused predicates enlarge grounded symbolic states while producing facts that no learned operator reads or changes.Such predicates therefore add representation and evaluation overhead without affecting operator application.
  • Selection: IPS retains only predicates appearing in at least one learned operator’s preconditions or effects.The retained set is computed from the learned operator set O and the predicates referenced by each operator.
  • Selection: After selection, the planner parses states with P′ instead of P, while operators remain unchanged and filtering requires only one scan over O.The scan is described as negligible compared with learning.

IV. EXPERIMENTS

The evaluation covers four TAMP domains of increasing sequential complexity and compares the original baseline with a complete pipeline combining macro-operator generation and IPS.

  • Domains: Four domains range from simple tabletop manipulation to multi-stage cooking, with task lengths increasing from 2–4 steps to approximately 32 steps and beyond.Cover uses two blocks, Blocks stacks six blocks in approximately 10 steps, Painting has approximately 32-step plans, and Kitchen is hardest.
  • Setup: Training combines expert demonstrations from ground-truth planning with random exploration trajectories that expose broader state transitions.Learned probabilistic operators are determinized for A* search, using PyBullet as the physics backend.
  • Comparison: The complete Ours pipeline integrates macro-operator generation and Iterative Predicate Selection against the original baseline.The comparison isolates the end-to-end system containing both contributions.

B. SYSTEM BEHAVIOR: LEARNED OPERATORS AND MACRO DISCOVERY

In Blocks, macro discovery identifies causally linked pick-and-place pairs and learns unified operators that absorb intermediate holding states. These macros reduce search time while preserving the expanded plan length.

  • Effect-complement analysis: Five causal candidates yield two validated macros: Pick→PutOnTable and Pick→Stack.The retained pairs occur in 34.1% and 28.0% of consecutive pairs, respectively, after reverse-order resolution.
  • Effect-complement analysis: Both validated macros use the causal link where Pick adds Holding(b), which the placement action deletes as its first precondition.
  • Unified macro operators: MacroPickStack unifies both sub-actions’ arguments and learns preconditions and effects without manual guidance.For the illustrated variant, the macro replaces b1 on b3 with b1 on b2 and leaves b3 clear, absorbing the intermediate Holding state.
  • Unified macro operators: A second OnTable variant is discovered automatically by treating distinct argument-sharing patterns as separate precondition patterns.
  • Planning implications: 0.040 ± 0.059 s versus 0.185 ± 0.912 s: macro-enabled Blocks planning is approximately 4.6× faster than the baseline.The action set grows from 4 individual operators to 7, while expanded plan lengths remain similar: 10.0 ± 1.1 versus 10.2 ± 1.1 steps.
  • Planning implications: In Kitchen, three validated Pick-to-placement pairs produce six macros, enabling 55.6-step expanded plans to solve all test problems in 0.051 ± 0.019 s.The baseline finds no plan even after 30 minutes on a single Kitchen problem.

C. BASELINE VS. FULL PIPELINE

Across four TAMP domains, the full pipeline combines macro generation with predicate selection, improving planning performance most strongly on longer tasks. The main exception is the short Cover domain, where macro branching adds overhead.

  • Success rates: 100.0 ± 0.0% success is achieved on Painting by both the baseline and the full pipeline.
  • Success rates: 100 test instances are solved in Kitchen by the macro-augmented pipeline, while approaches without macros achieve 0.0% success.
  • Success rates: The full pipeline reaches 100.0 ± 0.0% in Blocks versus 99.0 ± 2.0% for the baseline, while Cover reverses the ordering at 98.0 ± 4.0%.Across the three short domains, success remains within two points of the baseline.
  • Planning time: 0.040 ± 0.059 s versus 0.185 ± 0.912 s: Blocks planning shows an approximately 4.6× speedup with the full pipeline.Painting changes little, whereas Cover slows to 0.093 ± 0.190 s from 0.001 ± 0.001 s because its plans are only two to four steps long.
  • Structural properties: IPS reduces active predicates from 5 to 3 in Cover and from 6 to 5 in Blocks by removing predicates unused by learned operators.Painting and Kitchen retain all provided predicates because every one appears in the learned rules.
  • Structural properties: Macro generation adds 3 operators in Blocks, 1 in Cover, 1 in Painting, and 6 in Kitchen.The number can exceed validated causal pairs when argument-sharing patterns produce multiple macro variants.
  • Structural properties: Operator learning succeeds in every domain, including Kitchen, where planning rather than learning fails without macros.

D. ABLATION STUDY: ISOLATING COMPONENT CONTRIBUTIONS

The ablation isolates distinct roles for macros and IPS: macros primarily reduce search effort and can determine solvability, while IPS removes per-node predicate overhead.

  • Removing macros from Blocks lowers success from 100.0 to 99.0 ± 2.0% and increases planning time 4.4×, from 0.041 to 0.180 s.Removing IPS instead preserves 100.0% success and raises planning time only from 0.041 to 0.042 s.
  • Removing IPS adds one predicate and incurs a small per-node cost, whereas removing macros increases the number of nodes visited.The two components therefore affect different levels of planning computation.
  • Only macro removal causes complete Kitchen failure: success falls to 0.0±0.0% across all seeds and problems, with no plan found after lifting the timeout.Removing IPS leaves Kitchen essentially unchanged because every provided predicate is already referenced by a learned operator.
  • The macro benefit grows with task length rather than remaining a fixed percentage, becoming the only reason a plan is found beyond a certain horizon.This contrasts with short tasks, where macro overhead can outweigh its benefit.

V. CONCLUSION

The work combines macro-operator generation with predicate pruning to address planning-horizon and symbolic-state overhead in learned TAMP. Experiments indicate that the resulting benefit scales with task length, reaching substantial speedups and enabling plans unavailable to the baseline, while several simulation and offline-learning limitations remain.

  • The pipeline addresses two barriers left by learned-operator methods: unused predicates in the symbolic state and planning horizons that individual-action search cannot overcome.
  • Macro-operators are mined from causally linked action pairs, while Iterative Predicate Selection prunes up to 40% of unreferenced predicates.
  • The experiments suggest that macro benefits scale with task length, reaching ∼4.6× speedup on longer tasks and determining whether plans are found beyond roughly 50 steps.The baseline cannot solve the cited long-horizon domain within thirty minutes, whereas the pipeline solves it in ∼0.05 s.
  • The current system is limited to action pairs, cannot create predicates or learn continuous samplers, runs only in PyBullet simulation, and learns offline in one batch.
Loading 2608.23629v1…