PaperlayerView exact revision on arXiv

Source-linked AI summary

Riemannian Motion Policies

Nathan D. Ratliff, Jan Issac, Daniel Kappler, Stan Birchfield, Dieter Fox

arXiv:1801.02854v3cs.RO

TL;DR

Robot motion generation requires combining reactive controllers, optimization, and planning across multiple task spaces without losing geometric consistency. The paper introduces RMPs, pairing acceleration policies with Riemannian metrics and providing operators for transformation and metric-aware combination. The framework supports modular motion systems that solve complex collision-avoidance problems and integrate local controllers with anticipatory optimization on real robotic platforms.

  • Problem

    Existing motion-generation methods are difficult to combine because local policies can conflict and conventional transformations do not adequately track their geometry.

  • Method

    RMPs pair second-order motion policies with Riemannian metrics and combine them through geometrically consistent transformation and metric-weighted operators.

  • Results

    RMPs combine local reactive policies with planners, optimizers, and MPC while solving complex collision-avoidance tasks in simulation and on real robots.

  • Takeaways & Limitations

    The framework provides a modular configuration-space interface for integrating motion-generation methods across multiple time scales and task spaces.

Abstract

from arXiv · show

We introduce the Riemannian Motion Policy (RMP), a new mathematical object for modular motion generation. An RMP is a second-order dynamical system (acceleration field or motion policy) coupled with a corresponding Riemannian metric. The motion policy maps positions and velocities to accelerations, while the metric captures the directions in the space important to the policy. We show that RMPs provide a straightforward and convenient method for combining multiple motion policies and transforming such policies from one space (such as the task space) to another (such as the configuration space) in geometrically consistent ways. The operators we derive for these combinations and transformations are provably optimal, have linearity properties making them agnostic to the order of application, and are strongly analogous to the covariant transformations of natural gradients popular in the machine learning literature. The RMP framework enables the fusion of motion policies from different motion generation paradigms, such as dynamical systems, dynamic movement primitives (DMPs), optimal control, operational space control, nonlinear reactive controllers, motion optimization, and model predictive control (MPC), thus unifying these disparate techniques from the literature. RMPs are easy to implement and manipulate, facilitate controller design, simplify handling of joint limits, and clarify a number of open questions regarding the proper fusion of motion generation methods (such as incorporating local reactive policies into long-horizon optimizers). We demonstrate the effectiveness of RMPs on both simulation and real robots, including their ability to naturally and efficiently solve complicated collision avoidance problems previously handled by more complex planners.

I. INTRODUCTION

The paper addresses the difficulty of combining complex, competing motion-generation methods across task spaces. It introduces a geometrically consistent framework that combines reactive policies, optimizers, and planners while preserving modularity and supporting practical robotic behaviors.

  • Motivation: Motion generation spans collision-complete planning, reactive control, and optimization, but combining these methods remains unnecessarily complex.Existing approaches occupy different computational and behavioral regimes, creating a gap between planning tools and the simplicity of many human motions.
  • Motivation: Local obstacle and task policies can become unstable, slow near obstacles, or conflict when combined with conventional superposition and nullspace engineering.The paper revisits these techniques by focusing on how multiple competing local policies should be combined.
  • Framework: RMPs pair each motion policy with a Riemannian metric that represents the policy’s locally important directions.The metric is represented by a smoothly changing symmetric positive (semi-)definite matrix.
  • Framework: Geometrically consistent transformations and metric-weighted combinations provide modular operations analogous to pseudoinverses and superposition while preserving optimality properties.The framework tracks local geometry when policies move between spaces and when multiple policies are combined.
  • Integration: RMPs unify planners, motion optimizers, reactive controllers, dynamical systems, and MPC within a single configuration-space motion policy.Computationally intensive components can communicate with faster reactive loops through RMPs, supporting distributed computation.
  • Empirical scope: Experiments on simulated and real dual-arm platforms show that local policies can solve complex collision avoidance and combine with MPC-style optimization for anticipatory behavior.The framework also supports joint-limit handling and streaming optimized behavior as RMPs.

IV. RIEMANNIAN MOTION POLICIES (RMPS)

This section defines RMPs as acceleration policies paired with Riemannian metrics and introduces operators for transforming and combining them across robot spaces. These operators preserve policy geometry and support metric-aware aggregation.

  • RMP representation: An RMP is a second-order acceleration policy paired with a Riemannian metric in a possibly nonlinear space.The policy maps position and velocity to a desired acceleration, while the metric augments the dynamical system.
  • Consequences: The resulting approach enables motion policies to be combined while preserving geometry and supports transfer across robots without parameter retuning.The section presents this as a provably optimal control system for the stated transformations and combinations.
  • Transformations: RMP operators transform policies between task and configuration spaces while preserving their associated geometric information.Pushforward maps a configuration-space RMP to a task space, while pullback maps a task-space RMP back to its domain.
  • Combination: Multiple RMPs combine through metric-weighted averaging rather than unweighted policy addition.When metrics are axis-aligned scalar weights, the combination reduces to the traditional weighted average.
  • Geometric properties: Pullback transforms the metric as J⊤AJ and is connected to natural-gradient transformations in machine learning.The transformed differential equation corresponds to a natural vector field under the pullback metric.

B. Properties

RMP operations support order-independent combination and geometrically consistent transformation. Their covariance preserves the resulting motion under coordinate changes, while the framework also supports joint-limit handling.

  • RMP addition is commutative and associative, so combining policies is independent of grouping and order.
  • Pullback and pushforward operators are linear and associative across composed task maps.
  • Covariance to reparameterization makes RMP transformations unaffected by coordinate changes.
  • Transformed and directly constructed integral curves match up to numerical precision, including the corresponding pushforward result.
  • The same covariance property enables pulling constrained configuration-space RMPs through an inverse sigmoid into an unconstrained space satisfying joint limits.

V. MOTION GENERATION

Motion generation constructs RMPs for task maps, transforms them into configuration space, and combines them into one policy. The resulting optimization accounts for each desired acceleration and its metric.

  • The framework models robot behavior with RMPs attached to body points and their forward-kinematics task maps.
  • The configuration-space policy minimizes a cost combining desired accelerations while respecting their associated metrics.
  • For each task map, the method creates an RMP, pulls it back to configuration space, and sums the pulled-back RMPs.
  • The combined RMP can then be pulled into an unconstrained space to handle joint limits.
  • Each RMP is represented compactly by a vector field and metric that parameterize a quadratic term.

B. Basic local reactive policies

Basic local policies provide target attraction, collision avoidance, orientation control, and redundancy resolution through RMPs. These controllers are effective locally, but they do not plan across long distances.

  • Target: Target controllers pull an end effector toward a goal with velocity damping and can use identity or directionally stretched metrics.
  • Target: Soft normalization avoids division by zero by keeping its denominator positive as velocity error approaches zero.
  • Orientation: RMPs can express partial orientation constraints by applying target controllers to canonical points along selected axes.
  • Collision: Collision policies push the robot away from obstacles while damping velocity only along the obstacle direction, leaving orthogonal motion available for gliding.
  • Redundancy resolution and damping: Redundancy controllers use an identity metric, but the configuration-space formulation is not covariant and is therefore robot-dependent.
  • These local controllers react without planning and need more sophisticated techniques for long-distance navigation around large obstacles.

C. Integrating computationally intensive behaviors

RMPs integrate short-horizon optimization, long-range heuristics, and local reactive policies through geometrically consistent combination. Direction-aware metrics improve obstacle interaction, while long-range heuristics remain subject to workspace assumptions.

  • Integrating computationally intensive behaviors: An MPC-style RMP maps the current state to the first acceleration along a locally optimal trajectory defined by time-varying costs.
  • Integrating computationally intensive behaviors: RieMO uses a Gauss–Newton Hessian approximation as a pullback metric for the nonlinear manipulator and workspace.
  • Integrating computationally intensive behaviors: Because finite-horizon optimization is expensive, linearizations produce time-varying linear RMPs that can be evaluated faster and combined by local controllers.
  • Heuristic long-range arm navigation: Long-range navigation can avoid planning when the robot’s elbow is not blocked, using retraction toward a canonical configuration before reaching outward again.
  • Heuristic long-range arm navigation: The more sophisticated retraction heuristic performs slightly better than the simple attractor in some intentionally difficult environments.
  • Heuristic long-range arm navigation: Guiding points or approximate inverse-kinematics configurations steer the arm across obstacles and can encode a desired homotopy class.
  • Joint limits: Joint limits are handled by mapping constrained joint space through a sigmoid into an unconstrained space.
  • Collision avoidance: Direction-aware obstacle policies damp motion toward obstacles without damping perpendicular motion, enabling smoother gliding than weighted superposition.

VII. EXPERIMENTS

The experiments show that RMPs preserve performance when combining many controllers, solve difficult cluttered reaching tasks, support robust long-range navigation, and integrate with motion optimization.

  • C-space combination: RMPs retain modular pseudoinverse-style policy combination while achieving performance theoretically equivalent to centralized quadratic programming.This provides a geometrically consistent alternative for combining dynamical-system behaviors across task spaces.
  • C-space combination: Removing metric-spectrum information causes competing controllers to clash, substantially degrading performance, especially with up to 150 controllers sharing 7 arm degrees of freedom.Increasing controller weights improves stability but makes task achievement harder.
  • C-space combination: RMPs successfully solved all cluttered reaching tasks with smooth, predictable, and natural motion, whereas competing C-space controllers periodically collided with obstacles.The comparison used three environments containing four cylindrical obstacles each.
  • Long-range navigation: Retraction heuristics support long-range configuration-to-configuration navigation when the elbow is unblocked, and can generate behaviors or seed motion optimization.Splicing forward and backward retraction behaviors creates a guiding policy because both reach a common configuration.
  • Integrated motion generation: The framework combines local controllers with MPC-style continuous optimization to produce more anticipatory and coordinated behavior across simulated and physical manipulation platforms.The experiments used three dual-arm manipulation platforms in simulation and reality.

APPENDIX

The appendix formalizes RMPs as second-order policies paired with velocity-dependent metrics and develops geometrically consistent transformations and combinations across task spaces.

  • Task-space transformations: Task-space accelerations transform through the Jacobian, with ¨x = Jφ¨q + ˙Jφ ˙q; the appendix adopts an approximation that ignores the second-order Coriolis term.The approximation uses ¨x′i = ¨xi rather than ¨xi − ˙Ji ˙q.
  • RMP definition: An RMP pairs a smooth second-order motion policy with a velocity-dependent Riemannian metric, which may be represented by a symmetric semi-positive definite matrix.The policy supplies acceleration while the metric represents the local geometric weighting.
  • Optimal combination: The RMP algebra decomposes optimal operational-space combination into modular tools analogous to pseudoinverses and superposition while preserving optimality.This supports modular design, transformation, and combination of RMPs.
  • Pullback: RMP pullback transforms a task-space policy using B = J^T GJ and v = J^T Gf, connecting the operation to natural-gradient geometry.The pullback carries both the metric and the policy force into the configuration space.
  • Transformations: The framework defines pushforward and pullback operators that explicitly account for second-order terms, while noting that this pushforward differs from the common differential-geometric definition.For invertible maps, the two RMP operations are inverses.
  • Combination: RMPs can be combined modularly through metric-weighted averaging; when metrics are wiI, the operation reduces to a traditional weighted average.The combination is defined for multiple RMPs on the same domain.

E. The unresolved form

The unresolved RMP form represents policies in force-like coordinates, making pullback and combination computationally convenient while preserving unique resolution, path independence, and optimality.

  • E. The unresolved form: The unresolved form is an equivalence class of force-metric pairs rather than a single acceleration-metric representation.Equivalent representatives can differ by components in the nullspace of the generalized inverse.
  • E. The unresolved form: Its resolved representation is unique, and the unresolved form is often more computationally efficient and convenient for proofs.Resolution maps an unresolved equivalence class back to an equivalent resolved RMP.
  • E. The unresolved form: In force space, task-space forces propagate through ef = J^Tλ with generalized mass matrix M = J^T AJ before solving for configuration-space accelerations.This formulation explains why nullspace-equivalent force representatives yield the same resolved behavior.
  • F. Associativity, independence of computational path, and optimality: For a tree of task maps, recursively pulling back and combining RMPs to the root is independent of the computational path.The result follows from summation associativity, commutativity, and pullback linearity.
  • F. Associativity, independence of computational path, and optimality: RMP summation is commutative and associative, and pullback is linear, so combining and transforming policies can be reordered without changing the result.These properties are established through the unresolved representation.
  • F. Associativity, independence of computational path, and optimality: The root-level pullback and combination are optimal with respect to the stated quadratic objective.The proof identifies the result with direct pullbacks of leaf RMPs and the corresponding quadratic optimization solution.

G. Directionally stretched metrics

Directionally stretched metrics reshape task-space geometry around desired motion, while abstract task maps and cylindrical coordinates induce curved obstacle-avoiding attractors.

  • Metric construction: The soft V-shaped function smoothly transitions between a directionally stretched metric and an uninformed metric as position changes.Its behavior is controlled by a smooth weight and the desired acceleration field.
  • Metric construction: The soft-normalization function approaches normalized velocity for large inputs but smoothly approaches zero as velocity vanishes.This avoids a discontinuity at zero velocity.
  • Metric construction: Directionally stretched metrics behave like the outer product of normalized velocity for large vectors and approach zero for small vectors.They emphasize motion-aligned directions without imposing the same directional weighting near zero velocity.
  • Geometric task spaces: Abstract task maps can reshape workspace geometry so that pulled-back attractors follow curves defined by the map rather than straight workspace paths.This permits nonlinear attractors based on geometric structure encoded by ψ.
  • Attractor controllers: Attractors use position and damping gains plus an effective slowdown radius to regulate motion toward a target in an arbitrary task space.The attractor metric can be chosen to provide directional scaling.
  • Cylindrical task spaces: Cylindrical coordinates use radius, height, and angle; assigning a large radial weight encourages geodesics to remain on curves equidistant from the cylinder axis.Attractors in this coordinate space naturally curve around the cylindrical axis.

J. Collision avoidance controllers

The obstacle avoidance controller combines repulsion and damping, with activation and directional projection shaping responses near obstacles.

  • The controller is composed of repulsive and damping terms.
  • The repulsive term uses a position-based activation function with positive length-scale and gain parameters.
  • The projection operator scales obstacle-directed velocity and vanishes for motion orthogonal to or away from the obstacle.
  • The damping term uses the directional projection together with a position-based activation function.
  • Together, the obstacle force and metric form an obstacle avoidance RMP, with numerical stabilization introduced as the distance approaches zero.

K. C-space biasing

Redundancy resolution uses a configuration-space spring-damper system that attracts the robot toward target positions and velocities.

  • Redundancy resolution is implemented as a spring-damper system in configuration space.
  • The system uses positive position and velocity gains with target positions and velocities, often setting the target velocity to zero for pure damping.

L. Handling joint limits using pullbacks

Joint limits are handled by mapping unconstrained variables into constrained configuration space and modifying pullbacks near the limits. The resulting construction preserves transformed integral curves while avoiding explicit evaluation of a difficult inverse task map.

  • Joint-limit task map: An affine-transformed sigmoid maps unconstrained variables independently into each joint’s bounded interval.
  • Joint-limit task map: A regulator RMP bounds the unconstrained variables while preserving bounded-energy behavior for the constrained system.
  • Velocity-dependent regulation: The practical velocity-dependent map adjusts its Jacobian according to joint-limit proximity and motion direction.
  • Pullback modification: The pullback construction down-weights Jacobian columns near joint limits, reducing the policy’s dependency on those directions.
  • Computational limitation: The task-map transformation generally lacks a closed-form integral, making direct evaluation of the transformed dynamics difficult.
  • RMP integration: The construction applies within a broader RMP framework that also reduces motion optimization and optimal-control solutions to RMP streams.
  • RMP integration: Quadratic local approximations permit analytic action minimization and linear optimal policies, whose deviations can be represented as RMPs.
Loading 1801.02854v3…