Source-linked AI summary
Classical Planning in Deep Latent Space: Bridging the Subsymbolic-Symbolic Boundary
Masataro Asai, Alex Fukunaga
TL;DR
Classical planners require human-produced symbolic models, creating a knowledge-acquisition bottleneck for image-based and unforeseen tasks. LatPlan learns symbolic states and action models from unlabeled image transitions, plans with classical search, and demonstrated feasibility across three image-based puzzle domains, while scalability remains open.
Problem
Classical planners require human-provided symbolic models, creating a knowledge-acquisition bottleneck when planning must begin from unstructured inputs.
Method
LatPlan uses a State Autoencoder and unsupervised Action Model Acquisition to convert unlabeled image transitions and initial-goal images into symbolic planning problems.
Results
LatPlan demonstrated feasibility on image-based versions of the 8-puzzle, Towers of Hanoi, and LightsOut.
Takeaways & Limitations
The system automatically constructs a logical representation usable by a symbolic planner from unlabeled images across diverse problems.
Takeaways & Limitations
The approach assumes fully observable, deterministic domains and neural networks that can learn from available data, while its applicability and scalability require further work.
Abstract
from arXiv · showhide
Current domain-independent, classical planners require symbolic models of the problem domain and instance as input, resulting in a knowledge acquisition bottleneck. Meanwhile, although deep learning has achieved significant success in many fields, the knowledge is encoded in a subsymbolic representation which is incompatible with symbolic systems such as planners. We propose LatPlan, an unsupervised architecture combining deep learning and classical planning. Given only an unlabeled set of image pairs showing a subset of transitions allowed in the environment (training inputs), and a pair of images representing the initial and the goal states (planning inputs), LatPlan finds a plan to the goal state in a symbolic latent space and returns a visualized plan execution. The contribution of this paper is twofold: (1) State Autoencoder, which finds a propositional state representation of the environment using a Variational Autoencoder. It generates a discrete latent vector from the images, based on which a PDDL model can be constructed and then solved by an off-the-shelf planner. (2) Action Autoencoder / Discriminator, a neural architecture which jointly finds the action symbols and the implicit action models (preconditions/effects), and provides a successor function for the implicit graph search. We evaluate LatPlan using image-based versions of 3 planning domains: 8-puzzle, Towers of Hanoi and LightsOut.
Note
The manuscript combines machine-learning systems with classical, logic-based symbolic systems and provides introductory descriptions of neural-network architectures and training methods.
- The article integrates machine learning with classical, logic-based symbolic systems.
- It includes basic descriptions of neural-network architectures and training methods for readers unfamiliar with these areas.
1. Introduction
Classical planners depend on human-provided symbolic models, while neural systems use subsymbolic representations without symbolic-planning guarantees. LatPlan addresses this gap by automatically generating symbolic planning inputs from unlabeled image transitions and planning images.
- Domain-independent planners require structured symbolic inputs such as PDDL, which generally must be modeled by humans.
- This requirement creates a knowledge-acquisition bottleneck and obstructs planning in unforeseen situations where no human can create a model.
- Pure neural systems use subsymbolic representations and do not provide symbolic planners’ guarantees of deterministic completeness and solution optimality.
- LatPlan combines perceptual learning and symbolic planning to automatically bridge subsymbolic inputs and planner-compatible representations.
- Given unlabeled image transitions plus initial and goal images, LatPlan learns a symbolic representation, invokes a planner, and visualizes the resulting execution.
- The evaluation uses image-based versions of the 8-puzzle, LightsOut, and Towers of Hanoi domains.
2. Background
Classical planning represents states, goals, and actions symbolically and searches an implicit transition graph, but acquiring these models from unstructured inputs requires symbol grounding and action-model acquisition.
- 2.1 Classical Planning: A classical planning problem is represented as Π = ⟨P, O, I, G, A⟩, specifying predicates, objects, initial and goal states, and actions.
- 2.1 Classical Planning: The 8-puzzle state representation uses predicates such as empty, directional relations, and at, together with position and panel objects.
- 2.1 Classical Planning: A plan searches for a path from the initial state to a goal satisfying G by applying actions whose preconditions hold and effects update the state.
- 2.1 Classical Planning: State-of-the-art planners commonly use forward heuristic search, including A∗ for shortest paths and Greedy Best-First Search for potentially suboptimal paths.
- 2.1 Classical Planning: Its slide-up action representation adds an action symbol and specifies conditions and effects that move a tile into the empty position.
- 2.2 Knowledge Acquisition Bottleneck: Symbol grounding maps noisy, continuous, unstructured inputs to compact, discrete symbols, while action models encode transition causality through preconditions and effects.
- 2.2 Knowledge Acquisition Bottleneck: Existing approaches often assume symbolic inputs, human-assigned action names, or domain-dependent extractors for structures such as grids and pieces.
- 2.3 Autoencoders: An autoencoder learns a compressed latent representation by reconstructing its input and minimizing reconstruction loss.
3. LatPlan: System Architecture
LatPlan converts unlabeled raw-data transitions and an initial-goal pair into symbolic states, learns action models, plans in latent space, and decodes the plan into an interpretable sequence.
- LatPlan takes transition pairs as training input and an initial-goal data pair as planning input, returning a data sequence for the plan execution.
- Phase 1: Phase 1 trains a State Autoencoder to bidirectionally map raw data to propositional states and encode observed transitions symbolically.
- Phase 2: Phase 2 uses Action Model Acquisition to identify action symbols and learn action models without supervision.
- Phase 2: AMA1 generates PDDL from all valid transitions, whereas AMA2 jointly learns action symbols and implicit action models from a small transition subset.
- Phase 3: In Phase 3, the SAE encodes initial and goal images, a symbolic planner solves the problem, and intermediate latent states are decoded into images.
- The paper evaluates LatPlan as a high-level planner; mapping high-level actions to low-level actuation sequences is outside its scope.
4. SAE as a Gumbel-Softmax VAE
The State Autoencoder uses a Variational Autoencoder with Gumbel-Softmax to learn a bidirectional mapping between images and discrete propositional states. This representation supports symbolic reasoning while preserving reconstruction, generalization, robustness, and bijection goals.
- The architecture addresses why trivial image-to-proposition mappings are inadequate by targeting generalization, robustness, and bijection.
- The SAE is implemented as a Variational Autoencoder with a Gumbel-Softmax activation in its latent layer.
- Gumbel-Softmax provides differentiable categorical variables whose outputs approach discrete one-hot values as temperature τ decreases.
- Training combines reconstruction and variational losses, while denoising autoencoder techniques add noise robustness.
- Using two categories for each of N categorical variables yields N propositional state variables that can be consumed directly by symbolic reasoning systems.
- The trained SAE maps images to binary vectors with Encode and maps binary vectors back to images with Decode.
5. AMA1: Oracular PDDL Generator
AMA1 converts encoded image transitions into a grounded unit-cost STRIPS model that an off-the-shelf planner can solve. Its feasibility is demonstrated on several image-based puzzle domains, including noisy-input robustness.
- AMA1 produces a grounded unit-cost STRIPS planning problem in PDDL from transition data.
- AMA1 is an oracular strategy using all possible transitions, while the SAE itself is trained on only a subset of state images.
- Each image transition becomes an action whose preconditions are the encoded source state and whose effects are the bitwise differences between source and target states.
- The generated PDDL instance is solved with a modified Fast Downward planner and inherits the search properties of that planner within the captured state-space graph.
- AMA1 was evaluated on image-based puzzle domains including MNIST and photographic 8-puzzles, LightsOut, and distorted LightsOut.
- The system successfully solved problems with Gaussian or salt-and-pepper noise added to initial and goal images, attributed to the denoising autoencoder.
6. AMA2: Action Symbol Grounding
AMA2 learns anonymous action symbols and their effects from unlabeled symbolic transitions, then uses an Action Discriminator to filter valid successors for planning. This addresses AMA1’s impractical requirement for the entire state space while preserving LatPlan’s image-to-symbolic planning pipeline.
- AMA1 limitation: AMA1 correctly generates optimal plans only when all valid image-image transitions are supplied, making it impractical and motivating AMA2’s subset-based learning.The SAE nevertheless robustly learns image-to-propositional-vector mappings in the AMA1 setting.
- Action model acquisition: Action model acquisition identifies transition types, learns each action’s preconditions and effects, and can represent the result in PDDL.The action symbols are anonymous but abstract across multiple states.
- AMA2 overview: AMA2 focuses on grounding action symbols and learning a successor function for forward state-space search from a subset of transitions.It maintains an implicit action representation rather than directly producing a PDDL model.
- AAE and AD: AMA2 combines an Action Autoencoder and Action Discriminator to enumerate candidate successors and retain transitions classified as valid.Both networks operate on SAE-generated symbolic bitvectors and are trained unsupervised.
- Action Autoencoder: The Action Autoencoder uses a Gumbel-Softmax one-hot latent vector as an action label and reconstructs the successor state from the current state and action.The number of labels bounds the number of learned action symbols; unused labels are ignored.
- Action Discriminator: The Action Discriminator learns preconditions by classifying each state-transition pair as valid or invalid.This prevents generated successors from including invalid moves or states.
7. Related Work
LatPlan differs from prior neural and symbolic-planning approaches by accepting unstructured images, automatically grounding actions, and addressing noisy inputs. Its evaluation measures solved instances and model errors across image-based puzzle domains under clean and corrupted inputs.
- Comparison with prior work: LatPlan accepts unstructured 42x42 pixel arrays, unlike approaches that assume symbolic inputs or human-assigned action symbols.AMA2 automatically grounds action symbols rather than relying on labels such as move or interact.
- Comparison with prior work: LatPlan also implements the State Autoencoder as a denoising autoencoder, whereas the cited comparison does not explicitly address noisy input robustness.The comparison concerns both representation structure and action-symbol grounding.
- Evaluation: Relatively large Action Discriminator errors explain the increased number of failures in MNIST 8-puzzles.Failures in the broader evaluation were attributed to timeouts caused by costly neural-network successor generation.
8. Discussion and Conclusion
LatPlan combines neural representation learning with classical planning to construct symbolic problems from unlabeled image transitions. Its evaluation demonstrates feasibility across three image-based domains, while highlighting assumptions and latent-capacity trade-offs.
- Contributions: LatPlan learns propositional representations from images and uses them to construct and solve classical planning problems, returning visualized plan executions.Its State Autoencoder uses Gumbel-Softmax, while AMA2 learns action symbols and preconditions/effects from transitions.
- Evaluation: The system was demonstrated on image-based versions of 8-puzzle, Towers of Hanoi, and Lights Out.The 8-puzzle experiments included 42x42 MNIST images and scrambled real photographs, with 20,000 random transition images in one setup.
- Scope and assumptions: LatPlan assumes that domains are fully observable and deterministic and that neural networks can learn from the available data.Under these assumptions, the same system can solve different domains without modifying its code or neural-network architecture.
- Latent representation: The State Autoencoder uses a 36-bit latent layer, which covers the state spaces in the evaluated problems but must exceed the minimum encoding length.The paper reports that excessive capacity can introduce meaningless bits and duplicate symbolic states for the same image, potentially disconnecting the search graph.
- Latent representation: Larger latent capacity eases State Autoencoder training but makes the latent space more stochastic, creating a trade-off between learnability and search connectivity.State augmentation samples multiple bitvectors for the same image to obtain a connected search graph; it was used in Towers of Hanoi AMA1 experiments.
- Action and state modeling: The Action Autoencoder reconstructs successor states from before-and-after latent states, while discriminators classify transitions or states using PU-learning.The Action Discriminator learns from positive and mixed data, and the State Discriminator uses the same framework.
F.1 Planner in AMA1 experiments
The AMA1 experiments required a replacement PDDL-to-SAS converter because invariant detection became a bottleneck when transitions were represented as numerous ground actions.
- Planner implementation: Invariant detection in Fast Downward’s PDDL-to-SAS translator became a bottleneck because AMA1 represents individual transitions as a very large number of ground actions.The authors replaced the translator component without invariant detection for the experiments.
- Planner implementation: Each AMA1 experiment could require more than 7GB of memory and 4 hours on a Xeon E6-2676 CPU.
F.2 Planner in AMA2 experiments
AMA2 used a simple Python A* planner, but successor-state generation and filtering through the learned components—not the planner implementation—was the main time-consuming step.
- Planner implementation: AMA2 used a trivial Python A* planner, whose implementation could be inefficient compared with native compiled solvers.The authors state that planner performance was not their concern because low-level implementation was not the bottleneck.
- Planner implementation: Successor-state generation and filtering using the Action Autoencoder, Action Discriminator, and related components dominated AMA2 runtime.
- Heuristic: The goal-count heuristic measures the bitwise difference between the goal image’s latent representation and the current state.
Appendix G. Statement on Reproducibility
The authors planned to make the complete LatPlan source code and pretrained network weights publicly available on GitHub to support reproducibility.
- Reproducibility: LatPlan’s entire source code and pretrained network weights were to be made public on GitHub for reproducibility.