5,834 research outputs found
Neural Path Planning: Fixed Time, Near-Optimal Path Generation via Oracle Imitation
Fast and efficient path generation is critical for robots operating in
complex environments. This motion planning problem is often performed in a
robot's actuation or configuration space, where popular pathfinding methods
such as A*, RRT*, get exponentially more computationally expensive to execute
as the dimensionality increases or the spaces become more cluttered and
complex. On the other hand, if one were to save the entire set of paths
connecting all pair of locations in the configuration space a priori, one would
run out of memory very quickly. In this work, we introduce a novel way of
producing fast and optimal motion plans for static environments by using a
stepping neural network approach, called OracleNet. OracleNet uses Recurrent
Neural Networks to determine end-to-end trajectories in an iterative manner
that implicitly generates optimal motion plans with minimal loss in performance
in a compact form. The algorithm is straightforward in implementation while
consistently generating near-optimal paths in a single, iterative, end-to-end
roll-out. In practice, OracleNet generally has fixed-time execution regardless
of the configuration space complexity while outperforming popular pathfinding
algorithms in complex environments and higher dimension
Fastron: An Online Learning-Based Model and Active Learning Strategy for Proxy Collision Detection
We introduce the Fastron, a configuration space (C-space) model to be used as
a proxy to kinematic-based collision detection. The Fastron allows iterative
updates to account for a changing environment through a combination of a novel
formulation of the kernel perceptron learning algorithm and an active learning
strategy. Our simulations on a 7 degree-of-freedom arm indicate that proxy
collision checks may be performed at least 2 times faster than an efficient
polyhedral collision checker and at least 8 times faster than an efficient
high-precision collision checker. The Fastron model provides conservative
collision status predictions by padding C-space obstacles, and proxy collision
checking time does not scale poorly as the number of workspace obstacles
increases. All results were achieved without GPU acceleration or parallel
computing
Collision detection or nearest-neighbor search? On the computational bottleneck in sampling-based motion planning
The complexity of nearest-neighbor search dominates the asymptotic running
time of many sampling-based motion-planning algorithms. However, collision
detection is often considered to be the computational bottleneck in practice.
Examining various asymptotically optimal planning algorithms, we characterize
settings, which we call NN-sensitive, in which the practical computational role
of nearest-neighbor search is far from being negligible, i.e., the portion of
running time taken up by nearest-neighbor search is comparable, or sometimes
even greater than the portion of time taken up by collision detection. This
reinforces and substantiates the claim that motion-planning algorithms could
significantly benefit from efficient and possibly specifically-tailored
nearest-neighbor data structures. The asymptotic (near) optimality of these
algorithms relies on a prescribed connection radius, defining a ball around a
configuration , such that needs to be connected to all other
configurations in that ball. To facilitate our study, we show how to adapt this
radius to non-Euclidean spaces, which are prevalent in motion planning. This
technical result is of independent interest, as it enables to compare the
radial-connection approach with the common alternative, namely, connecting each
configuration to its nearest neighbors (-NN). Indeed, as we demonstrate,
there are scenarios where using the radial connection scheme, a solution path
of a specific cost is produced ten-fold (and more) faster than with -NN
Continuous-Time Gaussian Process Motion Planning via Probabilistic Inference
We introduce a novel formulation of motion planning, for continuous-time
trajectories, as probabilistic inference. We first show how smooth
continuous-time trajectories can be represented by a small number of states
using sparse Gaussian process (GP) models. We next develop an efficient
gradient-based optimization algorithm that exploits this sparsity and GP
interpolation. We call this algorithm the Gaussian Process Motion Planner
(GPMP). We then detail how motion planning problems can be formulated as
probabilistic inference on a factor graph. This forms the basis for GPMP2, a
very efficient algorithm that combines GP representations of trajectories with
fast, structure-exploiting inference via numerical optimization. Finally, we
extend GPMP2 to an incremental algorithm, iGPMP2, that can efficiently replan
when conditions change. We benchmark our algorithms against several
sampling-based and trajectory optimization-based motion planning algorithms on
planning problems in multiple environments. Our evaluation reveals that GPMP2
is several times faster than previous algorithms while retaining robustness. We
also benchmark iGPMP2 on replanning problems, and show that it can find
successful solutions in a fraction of the time required by GPMP2 to replan from
scratch.Comment: The International Journal of Robotics Research (IJRR), 2018, Volume
37, Issue 1
Learning-Based Proxy Collision Detection for Robot Motion Planning Applications
This paper demonstrates that collision detection-intensive applications such
as robotic motion planning may be accelerated by performing collision checks
with a machine learning model. We propose Fastron, a learning-based algorithm
to model a robot's configuration space to be used as a proxy collision detector
in place of standard geometric collision checkers. We demonstrate that
leveraging the proxy collision detector results in up to an order of magnitude
faster performance in robot simulation and planning than state-of-the-art
collision detection libraries. Our results show that Fastron learns a model
more than 100 times faster than a competing C-space modeling approach, while
also providing theoretical guarantees of learning convergence. Using the OMPL
motion planning libraries, we were able to generate initial motion plans across
all experiments with varying robot and environment complexities. With Fastron,
we can repeatedly perform planning from scratch at a 56 Hz rate, showing its
application toward autonomous surgical assistance task in shared environments
with human-controlled manipulators. All performance gains were achieved despite
using only CPU-based calculations, suggesting further computational gains with
a GPU approach that can parallelize tensor algebra. Code is available online
Efficient Penetration Depth Computation between Rigid Models using Contact Space Propagation Sampling
We present a novel method to compute the approximate global penetration depth
(PD) between two non-convex geometric models. Our approach consists of two
phases: offline precomputation and run-time queries. In the first phase, our
formulation uses a novel sampling algorithm to precompute an approximation of
the high-dimensional contact space between the pair of models. As compared with
prior random sampling algorithms for contact space approximation, our
propagation sampling considerably speeds up the precomputation and yields a
high quality approximation. At run-time, we perform a nearest-neighbor query
and local projection to efficiently compute the translational or generalized
PD. We demonstrate the performance of our approach on complex 3D benchmarks
with tens or hundreds of thousands of triangles, and we observe significant
improvement over previous methods in terms of accuracy, with a modest
improvement in the run-time performance.Comment: 10 pages. add the acknowledgemen
Proceedings of the 1st Workshop on Robotics Challenges and Vision (RCV2013)
Proceedings of the 1st Workshop on Robotics Challenges and Vision (RCV2013)Comment: http://compbio.cs.wayne.edu/robotics/rcv2013/proceedings-emb.pd
Online Mapping and Motion Planning under Uncertainty for Safe Navigation in Unknown Environments
Safe autonomous navigation is an essential and challenging problem for robots
operating in highly unstructured or completely unknown environments. Under
these conditions, not only robotic systems must deal with limited localisation
information, but also their manoeuvrability is constrained by their dynamics
and often suffer from uncertainty. In order to cope with these constraints,
this manuscript proposes an uncertainty-based framework for mapping and
planning feasible motions online with probabilistic safety-guarantees. The
proposed approach deals with the motion, probabilistic safety, and online
computation constraints by: (i) incrementally mapping the surroundings to build
an uncertainty-aware representation of the environment, and (ii) iteratively
(re)planning trajectories to goal that are kinodynamically feasible and
probabilistically safe through a multi-layered sampling-based planner in the
belief space. In-depth empirical analyses illustrate some important properties
of this approach, namely, (a) the multi-layered planning strategy enables rapid
exploration of the high-dimensional belief space while preserving asymptotic
optimality and completeness guarantees, and (b) the proposed routine for
probabilistic collision checking results in tighter probability bounds in
comparison to other uncertainty-aware planners in the literature. Furthermore,
real-world in-water experimental evaluation on a non-holonomic torpedo-shaped
autonomous underwater vehicle and simulated trials in the Stairwell scenario of
the DARPA Subterranean Challenge 2019 on a quadrotor unmanned aerial vehicle
demonstrate the efficacy of the method as well as its suitability for systems
with limited on-board computational power.Comment: The International Journal of Robotics Research (under review
Group Marching Tree: Sampling-Based Approximately Optimal Motion Planning on GPUs
This paper presents a novel approach, named the Group Marching Tree (GMT*)
algorithm, to planning on GPUs at rates amenable to application within control
loops, allowing planning in real-world settings via repeated computation of
near-optimal plans. GMT*, like the Fast Marching Tree (FMT) algorithm, explores
the state space with a "lazy" dynamic programming recursion on a set of samples
to grow a tree of near-optimal paths. GMT*, however, alters the approach of FMT
with approximate dynamic programming by expanding, in parallel, the group of
all active samples with cost below an increasing threshold, rather than only
the minimum cost sample. This group approximation enables low-level parallelism
over the sample set and removes the need for sequential data structures, while
the "lazy" collision checking limits thread divergence---all contributing to a
very efficient GPU implementation. While this approach incurs some
suboptimality, we prove that GMT* remains asymptotically optimal up to a
constant multiplicative factor. We show solutions for complex planning problems
under differential constraints can be found in ~10 ms on a desktop GPU and ~30
ms on an embedded GPU, representing a significant speed up over the state of
the art, with only small losses in performance. Finally, we present a scenario
demonstrating the efficacy of planning within the control loop (~100 Hz)
towards operating in dynamic, uncertain settings
Learning the Problem-Optimum Map: Analysis and Application to Global Optimization in Robotics
This paper describes a data-driven framework for approximate global
optimization in which precomputed solutions to a sample of problems are
retrieved and adapted during online use to solve novel problems. This approach
has promise for real-time applications in robotics, since it can produce
near-globally optimal solutions orders of magnitude faster than standard
methods. This paper establishes theoretical conditions on how many and where
samples are needed over the space of problems to achieve a given approximation
quality. The framework is applied to solve globally optimal collision-free
inverse kinematics (IK) problems, wherein large solution databases are used to
produce near-optimal solutions in sub-millisecond time on a standard PC
- …