PaperlayerView exact revision on arXiv

Source-linked AI summary

Robot Motion Planning in Learned Latent Spaces

Brian Ichter, Marco Pavone

arXiv:1807.10366v2cs.RO

TL;DR

The paper tackles the difficulty of planning for high-dimensional robotic systems by learning a latent space that supports sampling-based motion planning. L-SBMP combines learned state encoding, latent dynamics, and collision checking with L2RRT global search, and demonstrates the approach on visual and humanoid planning problems.

  • Problem

    Sampling-based motion planning becomes intractable for high-dimensional systems such as visual representations and humanoid robots, while existing learned embeddings primarily support local control.

  • Method

    L-SBMP learns an autoencoder, latent dynamics model, and collision checking network, then uses L2RRT to globally explore and plan in the latent space.

  • Results

    The methodology is demonstrated on two planning problems: visual planning in pixel space and humanoid robot planning.

  • Takeaways & Limitations

    L-SBMP provides a learned latent-space framework for applying global sampling-based exploration to complex robotic systems.

Abstract

from arXiv · show

This paper presents Latent Sampling-based Motion Planning (L-SBMP), a methodology towards computing motion plans for complex robotic systems by learning a plannable latent representation. Recent works in control of robotic systems have effectively leveraged local, low-dimensional embeddings of high-dimensional dynamics. In this paper we combine these recent advances with techniques from sampling-based motion planning (SBMP) in order to design a methodology capable of planning for high-dimensional robotic systems beyond the reach of traditional approaches (e.g., humanoids, or even systems where planning occurs in the visual space). Specifically, the learned latent space is constructed through an autoencoding network, a dynamics network, and a collision checking network, which mirror the three main algorithmic primitives of SBMP, namely state sampling, local steering, and collision checking. Notably, these networks can be trained through only raw data of the system's states and actions along with a supervising collision checker. Building upon these networks, an RRT-based algorithm is used to plan motions directly in the latent space - we refer to this exploration algorithm as Learned Latent RRT (L2RRT). This algorithm globally explores the latent space and is capable of generalizing to new environments. The overall methodology is demonstrated on two planning problems, namely a visual planning problem, whereby planning happens in the visual (pixel) space, and a humanoid robot planning problem.

I. INTRODUCTION

The paper addresses the difficulty of applying sampling-based motion planning to high-dimensional systems by learning a plannable latent space. It combines three learned networks with latent-space RRT exploration and demonstrates the methodology on visual and humanoid planning problems.

  • Motivation: High-dimensional dynamics and visual representations make direct sampling-based motion planning intractable for systems such as humanoids.SBMP maintains an implicit representation through sampling, local steering, and collision checking, but scales poorly beyond roughly ten dimensions.
  • Motivation: Local low-dimensional embeddings used in learning-based control do not directly support the global exploration required for motion planning.The paper proposes combining local latent representations with SBMP to construct a global implicit representation through local connections.
  • Contributions: L-SBMP uses an autoencoding network, dynamics network, and collision checking network to enable planning through a learned latent space.These networks can be trained from raw system states and control inputs together with a supervising collision checker.
  • Contributions: L2RRT globally explores the learned manifold by sampling encoded states, propagating latent dynamics, and projecting the final trajectory back to the full state space.The approach uses collision checking during latent exploration and is demonstrated on visual and humanoid planning problems.
  • Contributions: The paper evaluates L-SBMP on visual planning and humanoid robot planning problems beyond the reach of standard motion-planning approaches.The introduction identifies planning in pixel space and maneuvering a humanoid among obstacles as the two demonstrated domains.

II. PROBLEM STATEMENT

The paper formulates motion planning as finding a dynamically feasible, collision-free trajectory from an initial state to a goal region. It distinguishes continuous collision checking from discrete-time dynamics used for learning and feasibility.

  • Problem formulation: The robot state and control input lie in state space X and control space U, with continuous dynamics defined by f_X.The paper then adopts a discrete-time formulation for tractable dynamics learning.
  • Feasibility: A trajectory is a sequence of states and controls whose continuous interpolation must avoid obstacles while satisfying the discrete dynamics.Feasibility also requires starting at x_init and ending in X_goal.
  • Feasibility: The motion planning problem is to find a feasible trajectory for (x_init, X_goal, X_free), or report failure if none exists.The free space is defined as the state space excluding the obstacle space.

B. Sampling-based Motion Planning

Sampling-based motion planning searches an implicit representation of the state space using samples, local connections, and collision checking. The paper targets its scalability limits by learning a lower-dimensional latent space that supports these primitives.

  • Sampling-based motion planning: SBMP avoids explicitly constructing the state space by maintaining locally connected samples verified by a black-box collision checker.This representation supports global search and becomes more informative as samples are added.
  • RRT: RRT repeatedly samples a free state, selects the nearest tree node, propagates toward the sample, and adds the new node when the connection is collision-free.Its global search relies on sampling, local connection, and collision checking.
  • Motivation: Standard motion planning and SBMP become computationally difficult for pixel representations and highly dynamic robots, especially beyond ten dimensions.These limitations motivate performing SBMP in a learned low-dimensional latent space.
  • Latent-space formulation: The proposed latent space is learned from operating sequences of states and control inputs together with a separate local collision checker.The learned mappings encode states into Z, decode them back into X, enforce latent dynamics, and classify local latent transitions.

III. LEARNING A LATENT SPACE FOR ROBOTIC MOTION PLANNING

L-SBMP learns a latent representation that preserves the primitives needed for sampling-based planning and supports decoding planned motions back into the full state space.

  • Design requirements: Planning in the latent space requires sampling latent states, propagating known latent dynamics, and classifying local latent trajectories as collision-free.The decoded latent samples must also provide executable full-space motion plans.
  • Architecture: The L-SBMP architecture comprises an autoencoder, latent local dynamics model, and collision classifier.The autoencoder encodes high-dimensional states and decodes them for a subsequent controller; the dynamics model propagates latent states.

A. Learned Latent Space and Dynamics

L-SBMP learns a low-dimensional latent representation that reconstructs full system states and models their local dynamics. The dynamics prediction is trained with losses that enforce both state reconstruction and dynamically consistent latent predictions.

  • Autoencoding: The autoencoding network maps full states into a lower-dimensional latent space and reconstructs them back into the full state space.The encoder and decoder are trained using an ℓ2 reconstruction loss.
  • Latent dynamics: The dynamics network predicts the next latent state from the current latent state and control input.Its prediction is decoded and compared with the next full state, and separately compared with the next encoded latent state.
  • Latent dynamics: The dynamics loss uses a weighted controllability Gramian obtained by locally linearizing the latent dynamics around the current state and input.This weighting represents prediction errors according to the system’s local reachability structure.
  • Training stabilization: The training begins with an ℓ2 prediction loss and gradually shifts to the Gramian-weighted loss because the Gramian may initially be ill-conditioned.A small positive diagonal term is also added to the Gramian to ensure invertibility.

B. Learning a Collision Checker

L-SBMP learns a collision-checking network to classify whether continuous latent trajectories between two states are collision-free. Training is supervised by a full-state-space collision checker and incorporates environmental information as an input.

  • Collision-checking network: The collision-checking network classifies whether the continuous trajectory between two latent states is in collision.The network takes the two latent states and environmental information as inputs.
  • Training: The network is trained through supervised binary classification using a collision checker that evaluates trajectories in the full state space.The paper characterizes access to such a collision checker as a mild assumption.

IV. PLANNING IN THE LATENT SPACE

L2RRT globally searches the learned latent space by sampling encoded states, selecting nearby tree nodes, propagating learned dynamics, and collision-checking the resulting edges. Successful latent trajectories are selected by cost and decoded into full-state trajectories, but approximation prevents formal completeness and optimality guarantees.

  • Latent-space exploration: L2RRT builds an RRT-style tree in latent space by sampling learned-manifold states and dynamically propagating nearby tree nodes.Because the learned dynamics may be complex, the algorithm uses propagation rather than a steering function.
  • Latent-space exploration: The initial state and goal region are encoded into latent space, while exploration samples are generated by encoding randomly selected operational states.Restricting samples to encoded operational data keeps exploration near the learned manifold.
  • Tree expansion: L2RRT selects a low-cost tree node within a Gramian-weighted radius of each sample, or the nearest node when no node lies within that radius.The radius controls the tradeoff between exploiting good trajectories and exploring new ones.
  • Tree expansion: The algorithm randomly chooses a propagation time and controls, forward-propagates latent dynamics, and collision-checks each consecutive waypoint pair.A propagated endpoint is added to the tree only when all local collision probabilities exceed the safety threshold α.
  • Trajectory output: If the tree reaches the latent goal region, L2RRT selects the lowest-cost trajectory and decodes it into full-state states and controls.The trajectory cost may be based on control cost or the number of time steps.
  • Parameter choices: The propagation horizon Tmax controls approximate edge length, while α is tuned to the required safety level of collision checking.The paper describes the Gramian-weighted ball radius as balancing exploration and exploitation.
  • Limitations: Because the learned latent space is approximate, L2RRT does not have formal completeness or optimality guarantees.The paper identifies deriving such guarantees as future work.

V. EXPERIMENTAL RESULTS

The methodology is evaluated on two planning problems from domains described as intractable for traditional motion planning: visual planning and humanoid robot maneuvering.

  • Experimental tasks: The experiments evaluate a visual planning task and a humanoid planning task in domains where traditional motion planning approaches are intractable.The visual task uses a point robot with single-integrator dynamics in a cluttered environment, while the humanoid task involves maneuvering around obstacles.

A. Visual Planning Problem

The visual planning experiment evaluates L-SBMP on image-based robot navigation with randomly generated obstacles, showing that its learned latent space captures free-space structure and supports global planning. L2RRT generalizes to unseen environments, including narrow passages, with modest performance loss relative to true-state planners.

  • Problem setup: The visual robot is represented by 32 × 32 pixel images, with point-robot single-integrator dynamics and randomly generated circular and square obstacles.Training uses 10,000 environments for the autoencoder and dynamics network, and 25,000 environments for the collision checking network.
  • Learned representation: The full state is projected into a two-dimensional latent space using a deep-spatial autoencoder designed to preserve important visual features.The encoder uses a convolutional network followed by a spatial soft arg-max.
  • Learned representation: The learned latent space captures the robot’s position and removes latent regions corresponding to obstacles unseen during training.Collision states are omitted from the visualization, producing empty regions in the latent representation.
  • Learned representation: Errors are penalized less in regions where the same control input permits more movement, as reflected by the inverse weighted controllability Gramian.The latent-space ellipses are larger in directions where the representation is more spread.
  • Planning performance: L2RRT successfully generalizes to new visual planning problems and finds trajectories through narrow passages, which can then be passed to a local controller or trajectory optimizer.The planned trajectories are decoded back into the full state space for execution.
  • Planning performance: With 2,000 samples, L2RRT solved 92% of problems at 13% higher cost than FMT∗, while RRT-BestNear solved 96% at 5% higher cost than FMT∗.The comparison used 100 randomly generated planning problems; FMT∗ had more efficient state-space exploration through two-point boundary-value connections.

B. Humanoid Robot

The humanoid experiment applies L-SBMP to a 50-state dynamical system using a four-dimensional latent representation, then evaluates latent-space planning and collision checking. The learned latent structure captures position and yaw, while L2RRT solves the tested planning problems with high success and convergent cost.

  • Experimental setup: The humanoid system has 50 states, randomly generated spherical or cubic obstacles, and randomly generated initial and goal states.
  • Experimental setup: The state is encoded into a four dimensional latent space, while the collision checker receives latent states and obstacle geometry.The autoencoder and dynamics network use 1,000,000 state-control samples, and the collision checker uses 1,000,000 state-obstacle samples.
  • Learned latent structure: The learned latent structure primarily represents the humanoid’s position and yaw, while joint angles and velocities vary only slightly within gait.These dimensions most significantly govern the humanoid’s dynamics, including travel toward the control target.
  • Latent-space planning: L2RRT remains near the learned manifold and encapsulates obstacles through its collision checker while constructing the latent-space search.The resulting trajectory is projected into the full state space for execution.
  • Performance: After only a few hundreds of samples, L2RRT solves 100% of the planning problems, with trajectory cost converging as sample count increases.
  • Performance: The collision checking network classifies nearly 95% correctly with a 0.7% false positive rate, while 1000 samples require an average of 15 seconds.Traditional full-state planning comparisons are omitted because the 50-dimensional dynamical system is described as intractable for those approaches.

VI. CONCLUSIONS

The conclusion presents L-SBMP and L2RRT as a framework for combining learned latent representations with sampling-based planning for complex systems. It demonstrates generality across visual and humanoid planning while identifying data, dynamics, collision-learning, environment dependence, and theoretical guarantees as future work.

  • VI. CONCLUSIONS: L-SBMP combines an autoencoder, dynamics network, and collision checking network to support sampling, local connections, and collision checking in latent space.The networks can be trained from raw states and control inputs with a supervising collision checker.
  • VI. CONCLUSIONS: L2RRT globally explores the learned latent space to compute motion plans directly in it.
  • VI. CONCLUSIONS: Two experiments—visual-space planning and humanoid-robot planning—demonstrate the methodology’s generality and ability to generalize to new environments.
  • Future work: Future work includes determining data requirements, learning restricted dynamics with available steering functions, and learning collision checking without supervision.
  • Future work: Further directions include environment-dependent latent-space topology, task-and-motion integration, and conditions for deriving theoretical guarantees for L2RRT.
Loading 1807.10366v2…