Original: U SING D EEP L EARNING TO B OOTSTRAP A BSTRACTIONS FOR R OBOT P LANNING
Revised: U SING D EEP L EARNING TO B OOTSTRAP A BSTRACTIONS FOR R OBOT P LANNING

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT

Original: This paper addresses the problem of learning abstractions that boost robot planning performance while providing strong guarantees of reliability.
Revised: This paper addresses the problem of learning abstractions that boost robot planning performance while providing strong guarantees of reliability.

Original: Although stateof-the-art hierarchical robot planning algorithms allow robots to efﬁciently compute long-horizon motion plans for achieving user desired tasks, these methods typically rely upon environment-dependent state and action abstractions that need to be hand-designed by experts.
Revised: Although stateof-the-art hierarchical robot planning algorithms allow robots to efﬁciently compute long-horizon motion plans for achieving user desired tasks, these methods typically rely upon environment-dependent state and action abstractions that need to be hand-designed by experts.

Original: We present a new approach for bootstrapping the entire hierarchical planning process.
Revised: We present a new approach for bootstrapping the entire hierarchical planning process.

Original: This allows us to compute abstract states and actions for new environments automatically using the critical regions predicted by a deep neural network with an auto-generated robot-speciﬁc architecture.
Revised: This allows us to compute abstract states and actions for new environments automatically using the critical regions predicted by a deep neural network with an auto-generated robot-speciﬁc architecture.

Original: We show that the learned abstractions can be used with a novel multi-source bi-directional hierarchical robot planning algorithm that is sound and probabilistically complete.
Revised: We show that the learned abstractions can be used with a novel multi-source bi-directional hierarchical robot planning algorithm that is sound and probabilistically complete.

Original: An extensive empirical evaluation on twenty different settings using holonomic and non-holonomic robots shows that (a) our learned abstractions provide the information necessary for efﬁcient multi-source hierarchical planning; and that (b) this approach of learning, abstractions, and planning outperforms state-of-the-art baselines by nearly a factor of ten in terms of planning time on test environments not seen during training.
Revised: An extensive empirical evaluation on twenty different settings using holonomic and non-holonomic robots shows that (a) our learned abstractions provide the information necessary for efﬁcient multi-source hierarchical planning; and that (b) this approach of learning, abstractions, and planning outperforms state-of-the-art baselines by nearly a factor of ten in terms of planning time on test environments not seen during training.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Autonomous robots need to be able to efﬁciently compute long-horizon motion plans for achieving user desired tasks (Lo et al., 2018;
Revised: Autonomous robots need to be able to efﬁciently compute long-horizon motion plans for achieving user desired tasks (Lo et al., 2018;

Original: Duckworth et al., 2016; Luperto et al., 2021).
Revised: Duckworth et al., 2016; Luperto et al., 2021).

Original: E.g., consider a scenario where a robot R in a household environment is tasked to reach kitchen K from its current location B 1 (Fig. 1).
Revised: E.g., consider a scenario where a robot R in a household environment is tasked to reach kitchen K from its current location B 1 (Fig. 1).

Original: State-of-the-art motion planning algorithms such as PRM (Kavraki et al., 1996) and RRT (LaValle, 1998) use random sampling of lowlevel conﬁgurations to compute a path from the robot’s current location B 1 to its target location K .
Revised: State-of-the-art motion planning algorithms such as PRM (Kavraki et al., 1996) and RRT (LaValle, 1998) use random sampling of lowlevel conﬁgurations to compute a path from the robot’s current location B 1 to its target location K .

Original: Such sampling-based methods fail to efﬁciently sample conﬁgurations from conﬁned spaces such as doorways and corridors under uniform sampling (Molina et al., 2020).
Revised: Such sampling-based methods fail to efﬁciently sample conﬁgurations from conﬁned spaces such as doorways and corridors under uniform sampling (Molina et al., 2020).

Original: [Figure]
Revised: [Figure]

Original: On the other hand, humans tend to reason using abstract, high-level actions.
Revised: On the other hand, humans tend to reason using abstract, high-level actions.

Original: E.g., in the same scenario, we would use high-level (abstract) actions such as “go out of the room B1” , “pass through the corridor” , and “enter the kitchen K” .
Revised: E.g., in the same scenario, we would use high-level (abstract) actions such as “go out of the room B1” , “pass through the corridor” , and “enter the kitchen K” .

Original: These abstract actions allow us to reason over a long-horizon easily.
Revised: These abstract actions allow us to reason over a long-horizon easily.

Original: Currently, domain experts need to create such abstractions by hand.
Revised: Currently, domain experts need to create such abstractions by hand.

Original: This limits the scope and scalability of approaches for hierarchical planning (e.g., (Garrett et al., 2020; Shah et al., 2020)) to situations and domains where experts are available and able to correctly intuit the required abstractions.
Revised: This limits the scope and scalability of approaches for hierarchical planning (e.g., (Garrett et al., 2020; Shah et al., 2020)) to situations and domains where experts are available and able to correctly intuit the required abstractions.

Original: This paper shows that the required abstractions can be learned by identifying regions in the environment that are important to solve motion planning problems (loosely similar to landmarks in task planning).
Revised: This paper shows that the required abstractions can be learned by identifying regions in the environment that are important to solve motion planning problems (loosely similar to landmarks in task planning).

Original: Molina et al.
Revised: Molina et al.

Original: (2020) deﬁne such regions as critical regions .
Revised: (2020) deﬁne such regions as critical regions .

Original: Critical regions are analogous to landmarks in automated planning but unlike landmarks, critical regions do not necessarily have to be reached to achieve the goal.
Revised: Critical regions are analogous to landmarks in automated planning but unlike landmarks, critical regions do not necessarily have to be reached to achieve the goal.

Original: Fig. 1(b) shows a few candidate critical regions for the environment in Fig. 1(a).
Revised: Fig. 1(b) shows a few candidate critical regions for the environment in Fig. 1(a).

Original: In this paper, we investigate two major questions: 1) Can we use deep learning to automatically generate such abstractions for new environments?
Revised: In this paper, we investigate two major questions: 1) Can we use deep learning to automatically generate such abstractions for new environments?

Original: And 2) how can we use them to enable safe and more efﬁcient planning algorithms?
Revised: And 2) how can we use them to enable safe and more efﬁcient planning algorithms?

Original: The main contributions of this paper are: a formal foundation for hierarchical (state and action) abstractions based on the critical regions (similar to Fig. 1(c)) and a novel algorithm for on-the-ﬂy construction of such hierarchical abstraction using predicted critical regions.
Revised: The main contributions of this paper are: a formal foundation for hierarchical (state and action) abstractions based on the critical regions (similar to Fig. 1(c)) and a novel algorithm for on-the-ﬂy construction of such hierarchical abstraction using predicted critical regions.

Original: Abstractions computed using learning in this manner can be difﬁcult to use.
Revised: Abstractions computed using learning in this manner can be difﬁcult to use.

Original: In fact, our preliminary experiments showed that they do not help in standard single-source goal-directed search due to collision with obstacles in the environment.
Revised: In fact, our preliminary experiments showed that they do not help in standard single-source goal-directed search due to collision with obstacles in the environment.

Original: An additional contribution of this work is the ﬁnding that these abstractions empower effective multisource, multi-directional search algorithms.
Revised: An additional contribution of this work is the ﬁnding that these abstractions empower effective multisource, multi-directional search algorithms.

Original: In general, such search algorithms can be difﬁcult to use due to the absence of information about states that may lie close to a path to the goal.
Revised: In general, such search algorithms can be difﬁcult to use due to the absence of information about states that may lie close to a path to the goal.

Original: However, we found that when used with our auto-discovered abstract states, these algorithms signiﬁcantly outperform existing baselines.
Revised: However, we found that when used with our auto-discovered abstract states, these algorithms signiﬁcantly outperform existing baselines.

Original: Our formal framework provides a way to generate sound abstractions that satisfy downward reﬁnement property (Bacchus & Yang, 1991) for holonomic robots along with probabilistic completeness in the general case.
Revised: Our formal framework provides a way to generate sound abstractions that satisfy downward reﬁnement property (Bacchus & Yang, 1991) for holonomic robots along with probabilistic completeness in the general case.

Original: Our exhaustive empirical evaluation shows that our approach outperforms stateof-the-art sampling and learning-based motion planners and requires signiﬁcantly less time.
Revised: Our exhaustive empirical evaluation shows that our approach outperforms stateof-the-art sampling and learning-based motion planners and requires signiﬁcantly less time.

Original: This evaluation includes evaluation on a total of twenty different settings with four different robots, which include holonomic and non-holonomic robots.
Revised: This evaluation includes evaluation on a total of twenty different settings with four different robots, which include holonomic and non-holonomic robots.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Much of the prior work on the topic is focused on decomposing a motion planning problem into smaller subproblems to reduce its complexity.
Revised: Much of the prior work on the topic is focused on decomposing a motion planning problem into smaller subproblems to reduce its complexity.

Original: Several approaches have been proposed that use state decomposition to reduce the complexity of a motion planning problem.
Revised: Several approaches have been proposed that use state decomposition to reduce the complexity of a motion planning problem.

Original: Vertical cell decomposition (Chazelle, 1985) partitions the state space into a collection of vertical cells and computes a roadmap that passes through all of these cells.
Revised: Vertical cell decomposition (Chazelle, 1985) partitions the state space into a collection of vertical cells and computes a roadmap that passes through all of these cells.

Original: Brock & Kavraki (2001) propose a hierarchical method that uses wavefront expansion to compute the decomposition of the state space.
Revised: Brock & Kavraki (2001) propose a hierarchical method that uses wavefront expansion to compute the decomposition of the state space.

Original: While these approaches establish the foundation of decomposition-based motion planning, partitions generated through such approaches are arbitrary and do not provide any guarantees of completeness.
Revised: While these approaches establish the foundation of decomposition-based motion planning, partitions generated through such approaches are arbitrary and do not provide any guarantees of completeness.

Original: Zhang et al.
Revised: Zhang et al.

Original: (2018) use rejection sampling to reject unrelated samples to speed up SBMPs.
Revised: (2018) use rejection sampling to reject unrelated samples to speed up SBMPs.

Original: They use reinforcement learning to learn a policy that decides to accept or reject a new sample to expand the search tree.
Revised: They use reinforcement learning to learn a policy that decides to accept or reject a new sample to expand the search tree.

Original: While their approach reduces the search space to compute the path, it still needs to process samples generated from regions that are irrelevant for the current problem.
Revised: While their approach reduces the search space to compute the path, it still needs to process samples generated from regions that are irrelevant for the current problem.

Original: On the other hand, our hierarchical approach reﬁnes abstract plans into low-level motion plans which reduces the number of unnecessary samples.
Revised: On the other hand, our hierarchical approach reﬁnes abstract plans into low-level motion plans which reduces the number of unnecessary samples.

Original: TogglePRM (Denny & Amato, 2013) maintains roadmaps for free space and obstacle space in the conﬁguration space to estimate the narrow passages and sample points from these narrow passages.
Revised: TogglePRM (Denny & Amato, 2013) maintains roadmaps for free space and obstacle space in the conﬁguration space to estimate the narrow passages and sample points from these narrow passages.

Original: This approach works well for environments with α - (cid:15) -separable passages, even though it does not compute high-level abstractions.
Revised: This approach works well for environments with α - (cid:15) -separable passages, even though it does not compute high-level abstractions.

Original: Multiple approaches have used statistical learning to boost motion planning.
Revised: Multiple approaches have used statistical learning to boost motion planning.

Original: Wang et al.
Revised: Wang et al.

Original: (2021) present a comprehensive survey of methods that utilize a variety of learning methods to improve the efﬁciency of SBMPs.
Revised: (2021) present a comprehensive survey of methods that utilize a variety of learning methods to improve the efﬁciency of SBMPs.

Original: Multiple approaches discussed by Wang et al.
Revised: Multiple approaches discussed by Wang et al.

Original: (2021) use end-to-end deep learning to learn low-level reactive policies.
Revised: (2021) use end-to-end deep learning to learn low-level reactive policies.

Original: End-to-end approaches are attractive given if they succeed, they can compute solutions much faster than traditional approaches, but it is not exactly clear under which conditions these algorithms would succeed.
Revised: End-to-end approaches are attractive given if they succeed, they can compute solutions much faster than traditional approaches, but it is not exactly clear under which conditions these algorithms would succeed.

Original: Formally, these end-to-end deep learning-based approaches lack the guarantees about completeness and soundness that our approach provides.
Revised: Formally, these end-to-end deep learning-based approaches lack the guarantees about completeness and soundness that our approach provides.

Original: Wang et al.
Revised: Wang et al.

Original: (2021) also discuss approaches that use learning to aid sampling-based motion planning.
Revised: (2021) also discuss approaches that use learning to aid sampling-based motion planning.

Original: We discuss a few of these approaches that are relevant to this work.
Revised: We discuss a few of these approaches that are relevant to this work.

Original: Kurutach et al.
Revised: Kurutach et al.

Original: (2018) uses InfoGAN (Chen et al., 2016) to learn state-space partitioning for simple SE 2 robots.
Revised: (2018) uses InfoGAN (Chen et al., 2016) to learn state-space partitioning for simple SE 2 robots.

Original: While their empirical evaluation shows promising results, similarly to previous decomposition-based approaches, they do not provide any proof of completeness.
Revised: While their empirical evaluation shows promising results, similarly to previous decomposition-based approaches, they do not provide any proof of completeness.

Original: It is also not clear how their approach would scale to conﬁguration spaces that had more than two dimensions.
Revised: It is also not clear how their approach would scale to conﬁguration spaces that had more than two dimensions.

Original: On the other hand, our approach provides formal guarantees of completeness and soundness (for holonomic robots) and scales to high-dimensional spaces.
Revised: On the other hand, our approach provides formal guarantees of completeness and soundness (for holonomic robots) and scales to high-dimensional spaces.

Original: Ichter et al.
Revised: Ichter et al.

Original: (2018) and Kumar et al.
Revised: (2018) and Kumar et al.

Original: (2019) use a conditional variational autoencoder (CVAE)
Revised: (2019) use a conditional variational autoencoder (CVAE)

Original: (Sohn et al., 2015) to learn sampling distributions for the motion planning problems.
Revised: (Sohn et al., 2015) to learn sampling distributions for the motion planning problems.

Original: Ichter et al.
Revised: Ichter et al.

Original: (2020) use betweenness centrality to learn criticality score for low-level conﬁgurations.
Revised: (2020) use betweenness centrality to learn criticality score for low-level conﬁgurations.

Original: They uniformly sample a set of conﬁgurations from the environment and use conﬁgurations with higher criticality from this set to generate a roadmap.
Revised: They uniformly sample a set of conﬁgurations from the environment and use conﬁgurations with higher criticality from this set to generate a roadmap.

Original: Their results show signiﬁcant improvement over vanilla PRM but it is unclear how their approach would perform if the environment had regions that are important to compute motion plans yet difﬁcult to sample under uniform sampling.
Revised: Their results show signiﬁcant improvement over vanilla PRM but it is unclear how their approach would perform if the environment had regions that are important to compute motion plans yet difﬁcult to sample under uniform sampling.

Original: On the other hand, our approach would identify such important regions to overcome these challenges.
Revised: On the other hand, our approach would identify such important regions to overcome these challenges.

Original: While these approaches (Ichter et al., 2018; Kumar et al., 2019; Ichter et al., 2020) focus on biasing the sampling distribution towards narrow areas in the environment, our approach aims to build more general high-level abstractions for the conﬁguration space.
Revised: While these approaches (Ichter et al., 2018; Kumar et al., 2019; Ichter et al., 2020) focus on biasing the sampling distribution towards narrow areas in the environment, our approach aims to build more general high-level abstractions for the conﬁguration space.

Original: Molina et al.
Revised: Molina et al.

Original: (2020) use an image-based approach to learn and infer the sampling distribution using demonstrations.
Revised: (2020) use an image-based approach to learn and infer the sampling distribution using demonstrations.

Original: They use top-view images of the environment with critical regions highlighted in the image to learn to identify critical regions.
Revised: They use top-view images of the environment with critical regions highlighted in the image to learn to identify critical regions.

Original: While they develop a method for predicting critical regions and using them with a low-level motion planner, they do not use these critical regions for learning abstractions and performing hierarchical planning.
Revised: While they develop a method for predicting critical regions and using them with a low-level motion planner, they do not use these critical regions for learning abstractions and performing hierarchical planning.

Original: Our empirical results (Sec. 4) show that our hierarchical approach is much more effective than their non-hierarchical approach and yields signiﬁcantly better performance.
Revised: Our empirical results (Sec. 4) show that our hierarchical approach is much more effective than their non-hierarchical approach and yields signiﬁcantly better performance.

Original: Additionally, their approach is also restricted to navigational problems and does not scale to conﬁguration spaces with more than two degrees of freedom (DOFs).
Revised: Additionally, their approach is also restricted to navigational problems and does not scale to conﬁguration spaces with more than two degrees of freedom (DOFs).

Original: Deep learning has also been used for learning heuristics for high-level symbolic planning.
Revised: Deep learning has also been used for learning heuristics for high-level symbolic planning.

Original: Shen et al.
Revised: Shen et al.

Original: (2020) use hypergraph networks for learning heuristics for symbolic planning in the form of delete-relaxation representation of the actual planning problems.
Revised: (2020) use hypergraph networks for learning heuristics for symbolic planning in the form of delete-relaxation representation of the actual planning problems.

Original: Karia & Srivastava (2021) learn generalizable heuristics for high-level planning without explicit action representations in symbolic logic.
Revised: Karia & Srivastava (2021) learn generalizable heuristics for high-level planning without explicit action representations in symbolic logic.

Original: In contrast, we focus on learning critical regions and creating high-level abstractions along with algorithms that work with these learned high-level abstractions.
Revised: In contrast, we focus on learning critical regions and creating high-level abstractions along with algorithms that work with these learned high-level abstractions.

Original: Liu et al.
Revised: Liu et al.

Original: (2020) use semantic information to bias the sampling distribution for navigational problems in partially known environments.
Revised: (2020) use semantic information to bias the sampling distribution for navigational problems in partially known environments.

Original: Compared to it, our approach is not navigational problems and does not require semantic information explicitly but aims to learn such a notion in the form of critical regions.
Revised: Compared to it, our approach is not navigational problems and does not require semantic information explicitly but aims to learn such a notion in the form of critical regions.

Original: SPARK and FLAME (Chamzas et al., 2020) use state decomposition to store past experience and use it when queried for similar state decompositions.
Revised: SPARK and FLAME (Chamzas et al., 2020) use state decomposition to store past experience and use it when queried for similar state decompositions.

Original: While their approach efﬁciently uses the experience from previous iterations, it requires carefully crafted state decompositions in order to cover a large number of scenarios, whereas our approach generates state abstraction automatically using the predicted critical regions.
Revised: While their approach efﬁciently uses the experience from previous iterations, it requires carefully crafted state decompositions in order to cover a large number of scenarios, whereas our approach generates state abstraction automatically using the predicted critical regions.

Original:  L EARNING A BSTRACTIONS AND P LANNING
Revised:  L EARNING A BSTRACTIONS AND P LANNING

Original: Our approach uses a learned deep neural network to identify critical regions in a given environment and use these identiﬁed critical regions to generate hierarchical state and action abstractions.
Revised: Our approach uses a learned deep neural network to identify critical regions in a given environment and use these identiﬁed critical regions to generate hierarchical state and action abstractions.

Original: The learned neural network predicts critical regions for each joint of the robot.
Revised: The learned neural network predicts critical regions for each joint of the robot.

Original: This requires a robotspeciﬁc architecture for the robot.
Revised: This requires a robotspeciﬁc architecture for the robot.

Original: Our approach uses UNet (Ronneberger et al., 2015) as the base deep network and automatically updates it using geometry and degrees of freedom of the robot to learn to predict critical regions for the given conﬁguration space.
Revised: Our approach uses UNet (Ronneberger et al., 2015) as the base deep network and automatically updates it using geometry and degrees of freedom of the robot to learn to predict critical regions for the given conﬁguration space.

Original: We include a detailed discussion on updating network architecture and training the network in the appendix.
Revised: We include a detailed discussion on updating network architecture and training the network in the appendix.

Original: Now, we ﬁrst discuss our approach for generating and using abstractions using critical regions.
Revised: Now, we ﬁrst discuss our approach for generating and using abstractions using critical regions.

Original: 3. G ENERATING AND U SING A BSTRACTIONS
Revised: 3. G ENERATING AND U SING A BSTRACTIONS

Original: In this section, we describe our approach -- H ierarchical A bstraction-guided R obot P lanner (HARP) -- for generating abstract states and actions and using them to efﬁciently perform hierarchical planning.
Revised: In this section, we describe our approach -- H ierarchical A bstraction-guided R obot P lanner (HARP) -- for generating abstract states and actions and using them to efﬁciently perform hierarchical planning.

Original: We assume standard notion of motion planning (LaValle, 2006) problem.
Revised: We assume standard notion of motion planning (LaValle, 2006) problem.

Original: We also deﬁne critical regions in the same way deﬁned by Molina et al.
Revised: We also deﬁne critical regions in the same way deﬁned by Molina et al.

Original: We grow Voronoi cells around each predicted critical regions to generate state and action abstractions.
Revised: We grow Voronoi cells around each predicted critical regions to generate state and action abstractions.

Original: We deﬁne a labelling function (cid:96) that maps each Voronoi cell to an abstract state s ∈ S .
Revised: We deﬁne a labelling function (cid:96) that maps each Voronoi cell to an abstract state s ∈ S .

Original: We deﬁne abstract actions as transitions between these abstract states.
Revised: We deﬁne abstract actions as transitions between these abstract states.

Original: More details and theoretical guarantees about the leaned abstractions are present in Appendix B.
Revised: More details and theoretical guarantees about the leaned abstractions are present in Appendix B.

Original: A na´ıve approach would be to generate a complete Voronoi diagram and then extract abstract states and actions from it.
Revised: A na´ıve approach would be to generate a complete Voronoi diagram and then extract abstract states and actions from it.

Original: This would require iterating over all conﬁgurations in the conﬁguration space and computing a large number of motion plans to identify executable abstract actions.
Revised: This would require iterating over all conﬁgurations in the conﬁguration space and computing a large number of motion plans to identify executable abstract actions.

Original: This is expensive (and practically infeasible) for continuous low-level conﬁguration spaces.
Revised: This is expensive (and practically infeasible) for continuous low-level conﬁguration spaces.

Original: Instead, we use the RBVD as an implicit concept.
Revised: Instead, we use the RBVD as an implicit concept.

Original: We generate abstractions on-the-ﬂy by computing membership of low-level conﬁgurations in abstract states only when needed.
Revised: We generate abstractions on-the-ﬂy by computing membership of low-level conﬁgurations in abstract states only when needed.

Original: Input: Conﬁguration space X , a region predictor Φ , an initial conﬁguration x 0 ∈ X , goal conﬁguration x g ∈ X , a custom heuristic h , low-level sampling-based motion planner MP
Revised: Input: Conﬁguration space X , a region predictor Φ , an initial conﬁguration x 0 ∈ X , goal conﬁguration x g ∈ X , a custom heuristic h , low-level sampling-based motion planner MP

Original: Output: A motion plan τ 1 ρ ← predict critical regions( Φ , X , x 0 , x g ) 2 S , A ← generate state action abstractions( ρ , X ) 3 s 0 , s g ← get HL state( S , ρ , x 0 ), get HL state( S , ρ , x g ) 4 P ← multi-source bi-directional beam search( S ,
Revised: Output: A motion plan τ 1 ρ ← predict critical regions( Φ , X , x 0 , x g ) 2 S , A ← generate state action abstractions( ρ , X ) 3 s 0 , s g ← get HL state( S , ρ , x 0 ), get HL state( S , ρ , x g ) 4 P ← multi-source bi-directional beam search( S ,

Original: A , s 0 , s g ) 5 τ ← reﬁne path( P , MP ) 

Revised: A , s 0 , s g ) 5 τ ← reﬁne path( P , MP )

Original: h ← update heuristic( τ , S ) 7 return τ
Revised: h ← update heuristic( τ , S ) 7 return τ

Original: Algorithm 1 describes our approach for generating and using hierarchical abstractions.
Revised: Algorithm 1 describes our approach for generating and using hierarchical abstractions.

Original: Given the conﬁguration space X and initial and goal conﬁgurations ( x 0 and x g ) of the robot R , HARP uses a learned
Revised: Given the conﬁguration space X and initial and goal conﬁgurations ( x 0 and x g ) of the robot R , HARP uses a learned

Original: DNN Φ to generate a set of critical regions ρ (we include details about learning this
Revised: DNN Φ to generate a set of critical regions ρ (we include details about learning this

Original: DNN in Appendix E) (line 1 ).
Revised: DNN in Appendix E) (line 1 ).

Original: The remainder of Alg.
Revised: The remainder of Alg.

Original: 1 can be broken down into three important steps: 1) computing a set of candidate high-level plans, 2) reﬁning candidate high-level plans into a low-level trajectory, and 3) updating the heuristic for abstract states.
Revised: 1 can be broken down into three important steps: 1) computing a set of candidate high-level plans, 2) reﬁning candidate high-level plans into a low-level trajectory, and 3) updating the heuristic for abstract states.

Original: We now explain each of these steps in detail.
Revised: We now explain each of these steps in detail.

Original: Computing High-Level Plans To compute high-level plans that reach the goal conﬁguration x g from the initial conﬁguration x 0 , ﬁrst we determine abstract initial and goal states s 0 and s g corresponding to the initial and goal conﬁgurations x 0 and x g (line 3 ).
Revised: Computing High-Level Plans To compute high-level plans that reach the goal conﬁguration x g from the initial conﬁguration x 0 , ﬁrst we determine abstract initial and goal states s 0 and s g corresponding to the initial and goal conﬁgurations x 0 and x g (line 3 ).

Original: To do this efﬁciently, we store sampled points from each critical region in a k-d-tree and query it to determine the abstract state for the given low-level conﬁgurations without explicitly constructing the complete Voronoi diagram.
Revised: To do this efﬁciently, we store sampled points from each critical region in a k-d-tree and query it to determine the abstract state for the given low-level conﬁgurations without explicitly constructing the complete Voronoi diagram.

Original: This allows us to dynamically and efﬁciently determine high-level states for low-level conﬁgurations.
Revised: This allows us to dynamically and efﬁciently determine high-level states for low-level conﬁgurations.

Original: Once we determine initial and goal states s 0 and s g , we use our high-level planner to compute a set of candidate high-level plans going from s 0 to s g (line 4 ).
Revised: Once we determine initial and goal states s 0 and s g , we use our high-level planner to compute a set of candidate high-level plans going from s 0 to s g (line 4 ).

Original: To compute these candidate high-level plans, we develop a multi-source bi-directional variant of beam search (Lowerre, 1976) that yields multiple high-level candidate plans.
Revised: To compute these candidate high-level plans, we develop a multi-source bi-directional variant of beam search (Lowerre, 1976) that yields multiple high-level candidate plans.

Original: We call this multi-source bi-directional beam search .
Revised: We call this multi-source bi-directional beam search .

Original: We include the pseudocode for vanilla and multi-source bi-directional beam search in Appendix D.
Revised: We include the pseudocode for vanilla and multi-source bi-directional beam search in Appendix D.

Original: Intuitively, this algorithm works as follows: we use a priority queue to maintain a fringe to keep track of the current state of the search.
Revised: Intuitively, this algorithm works as follows: we use a priority queue to maintain a fringe to keep track of the current state of the search.

Original: We initialize this fringe with multiple randomly sampled abstract states to allow the beam search to start from multiple sources.
Revised: We initialize this fringe with multiple randomly sampled abstract states to allow the beam search to start from multiple sources.

Original: We select and expand these nodes in a speciﬁc order to compute paths that reach from the initial state to the goal state.
Revised: We select and expand these nodes in a speciﬁc order to compute paths that reach from the initial state to the goal state.

Original: Formally, the nodes in the fringe are expanded as follows: Let n be a node in the fringe.
Revised: Formally, the nodes in the fringe are expanded as follows: Let n be a node in the fringe.

Original: We select the node to expand using f ( n ) =
Revised: We select the node to expand using f ( n ) =

Original: g ( n ) + h ( n ) , where g ( n ) is the cost of the path heading to n (unit cost for each action) and h ( n ) is a custom heuristic that is deﬁned as follows.
Revised: g ( n ) + h ( n ) , where g ( n ) is the cost of the path heading to n (unit cost for each action) and h ( n ) is a custom heuristic that is deﬁned as follows.

Original: Let m be the parent of n and let s n and s m be the abstract states corresponding to the nodes n and m .
Revised: Let m be the parent of n and let s n and s m be the abstract states corresponding to the nodes n and m .

Original: The heuristic h ( n ) is computed as:
Revised: The heuristic h ( n ) is computed as:

Original: [Equation]
Revised: [Equation]

Original: Here, h (cid:48) ( s 1 , s 2 ) =
Revised: Here, h (cid:48) ( s 1 , s 2 ) =

Original: (cid:15)
Revised: (cid:15)

Original: 12 d r ( r 1 , r 2 ) deﬁnes the estimated distance between abstract high-level states sand s 2 with corresponding critical regions r 1 and r 2 respectively.
Revised: 12 d r ( r 1 , r 2 ) deﬁnes the estimated distance between abstract high-level states sand s 2 with corresponding critical regions r 1 and r 2 respectively.

Original: s i is the initial abstract state and s g is the goal abstract state.
Revised: s i is the initial abstract state and s g is the goal abstract state.

Original: (cid:15) ij ∈ (0 , 1] is a constant that accounts for imprecise abstract actions.
Revised: (cid:15) ij ∈ (0 , 1] is a constant that accounts for imprecise abstract actions.

Original: Alg.
Revised: Alg.

Original: 1 dynamically changes it to update the heuristic function (line 6 ) and making it more accurate.
Revised: 1 dynamically changes it to update the heuristic function (line 6 ) and making it more accurate.

Original: Initially, (cid:15) ij is set to 1 for all i and j .
Revised: Initially, (cid:15) ij is set to 1 for all i and j .

Original: Once a low-level trajectory τ is computed (explained later), we compute the abstraction ¯ τ of this trajectory.
Revised: Once a low-level trajectory τ is computed (explained later), we compute the abstraction ¯ τ of this trajectory.

Original: For each consecutive pair of abstract states (cid:104) s i , s j (cid:105) in ¯ τ , we decrease the value of (cid:15) ij by (cid:15) ij / 2 .
Revised: For each consecutive pair of abstract states (cid:104) s i , s j (cid:105) in ¯ τ , we decrease the value of (cid:15) ij by (cid:15) ij / 2 .

Original: This allows HARP to use experience from previously computed trajectories to prioritize abstract actions that have low-level reﬁnements to compute accurate high-level plans.
Revised: This allows HARP to use experience from previously computed trajectories to prioritize abstract actions that have low-level reﬁnements to compute accurate high-level plans.

Original: After an abstract state s j is selected from the fringe, its successors are created by applying abstract actions on it and adding these successors to the fringe.
Revised: After an abstract state s j is selected from the fringe, its successors are created by applying abstract actions on it and adding these successors to the fringe.

Original: This process continues until k high-level plans are found or the fringe is empty.
Revised: This process continues until k high-level plans are found or the fringe is empty.

Original: Once we generate a set of candidate high-level plans from multi-source bi-directional beam search, we use a low-level planner to reﬁne these plans into a low-level collision-free trajectory from initial low-level conﬁguration x 0 to goal conﬁguration x g (line 5 ).
Revised: Once we generate a set of candidate high-level plans from multi-source bi-directional beam search, we use a low-level planner to reﬁne these plans into a low-level collision-free trajectory from initial low-level conﬁguration x 0 to goal conﬁguration x g (line 5 ).

Original: Reﬁning High-level Plans While any probabilistically complete motion planner can be used to reﬁne the computed high-level plans into a low-level trajectory between given two conﬁgurations, we use Learn and Link Planner (LLP)
Revised: Reﬁning High-level Plans While any probabilistically complete motion planner can be used to reﬁne the computed high-level plans into a low-level trajectory between given two conﬁgurations, we use Learn and Link Planner (LLP)

Original: (Molina et al., 2020) as a low-level planner in
Revised: (Molina et al., 2020) as a low-level planner in

Original: HARP ( MP in Alg. 1) as it allows us to easily use the abstract states and their critical regions to efﬁciently compute motion plans.
Revised: HARP ( MP in Alg. 1) as it allows us to easily use the abstract states and their critical regions to efﬁciently compute motion plans.

Original: LLP is a sampling-based motion planner that initializes exploration trees rooted at N samples from the conﬁguration space and extends these exploration trees until they connect and form a single tree.
Revised: LLP is a sampling-based motion planner that initializes exploration trees rooted at N samples from the conﬁguration space and extends these exploration trees until they connect and form a single tree.

Original: Once a single tree is formed, the planner uses
Revised: Once a single tree is formed, the planner uses

Original: Dijkstra’s Algorithm (Dijkstra, 1959) to compute a path from the initial state to the goal state.
Revised: Dijkstra’s Algorithm (Dijkstra, 1959) to compute a path from the initial state to the goal state

Original: [Figure]
Revised: [Figure]

Original: for navigational problems while (H) and (I) are used for manipulation problems.

Original: In order to use LLP to reﬁne a set of candidate high-level plans simultaneously, we ﬁrst select a subset of critical regions ¯ ρ ⊆ ρ that includes all critical regions corresponding to all high-level states in candidate plans.
Revised: In order to use LLP to reﬁne a set of candidate high-level plans simultaneously, we ﬁrst select a subset of critical regions ¯ ρ ⊆ ρ that includes all critical regions corresponding to all highlevel states in candidate plans.

Original: We use this subset of critical regions ¯ ρ to provide initial samples to initialize exploration trees of LLP.
Revised: We use this subset of critical regions ¯ ρ to provide initial samples to initialize exploration trees of LLP.

Original: In this work, we generate M samples from the set of critical regions ¯ ρ and generate the rest of the N − M samples using uniform random sampling.
Revised: In this work, we generate M samples from the set of critical regions ¯ ρ and generate the rest of the N − M samples using uniform random sampling.

Original: Similarly, to expand these exploration trees, we generate a ﬁxed number of samples from the set critical regions ρ and then continue with uniform sampling.
Revised: Similarly, to expand these exploration trees, we generate a ﬁxed number of samples from the set critical regions ρ and then continue with uniform sampling.

Original: We use these characteristics of our algorithm to show that our approach is probabilistic complete .
Revised: We use these characteristics of our algorithm to show that our approach is probabilistic complete .

Original: Theorem 3.1.
Revised: Theorem 3.1.

Original: If the low-level motion planner ( MP in Alg. 1) is probabilistically complete, then HARP is probabilistically complete.
Revised: If the low-level motion planner ( MP in Alg. 1) is probabilistically complete, then HARP is probabilistically complete.

Original: Proof.
Revised: Proof.

Original: (Sketch)
Revised: (Sketch)

Original: While reﬁning high-level plans to a low-level motion plan (line 5 in Alg. 1), HARP uses a ﬁxed number of samples from the critical regions along the high-level plans to initialize a lowlevel motion planner.
Revised: While reﬁning high-level plans to a low-level motion plan (line 5 in Alg. 1), HARP uses a ﬁxed number of samples from the critical regions along the high-level plans to initialize a low-level motion planner.

Original: This does not reduce the set of support (regions with a non-zero probability of being sampled) of the sampling distribution being used by the motion planner.
Revised: This does not reduce the set of support (regions with a non-zero probability of being sampled) of the sampling distribution being used by the motion planner.

Original:  E MPIRICAL E VALUATION
Revised:  E MPIRICAL E VALUATION

Original: We extensively evaluate our approach in twenty different scenarios with four different robots.
Revised: We extensively evaluate our approach in twenty different scenarios with four different robots.

Original: All experiments were conducted on a system running Ubuntu 18.04 with 8-core i9 processor, 32 GB
Revised: All experiments were conducted on a system running Ubuntu 18.04 with 8-core i9 processor, 32 GB

Original: RAM , and an Nvidia 2060 GPU (our approach uses only a single core) OpenRAVE robot simulator (Diankov, 2010).
Revised: RAM , and an Nvidia 2060 GPU (our approach uses only a single core) OpenRAVE robot simulator (Diankov, 2010).

Original: We compare our approach with state-of-the-art motion planners such as
Revised: We compare our approach with state-of-the-art motion planners such as

Original: RRT (LaValle, 1998), PRM (Kavraki et al., 1996), and BiRRT (Kuffner & LaValle, 2000).
Revised: RRT (LaValle, 1998), PRM (Kavraki et al., 1996), and BiRRT (Kuffner & LaValle, 2000).

Original: As LLP is implemented using Python , we use the Python implementation of the baseline algorithms available at https://ompl.kavrakilab.org/ for comparison.
Revised: As LLP is implemented using Python , we use the Python implementation of the baseline algorithms available at https://ompl.kavrakilab.org/ for comparison.

Original: Our training data, code, trained model, and results are available at [link removed for submission].
Revised: Our training data, code, trained model, and results are available at [link removed for submission].

Original: We evaluate our approach with four different robots.
Revised: We evaluate our approach with four different robots.

Original: We use two holonomic robots: a 3 -DOF rectangular robot (R) and a 4 -DOF hinged robot (H).
Revised: We use two holonomic robots: a 3 -DOF rectangular robot (R) and a 4 -DOF hinged robot (H).

Original: Both robots can move along X and Y axes and rotate its body around Z axis.
Revised: Both robots can move along X and Y axes and rotate its body around Z axis.

Original: The hinged robot also contains an additional hinged joint that can rotate in the range [ − π 2 , π 2 ] .
Revised: The hinged robot also contains an additional hinged joint that can rotate in the range [ − π 2 , π 2 ] .

Original: We also evaluate our approach with a non-holonomic rectangular car robot (Car) that has 3 -DOFs.
Revised: We also evaluate our approach with a non-holonomic rectangular car robot (Car) that has 3 -DOFs.

Original: Controls available to operate the robot were linear velocity v ∈ [ − 0 .
Revised: Controls available to operate the robot were linear velocity v ∈ [ − 0 .

Original: 2 , 0 . 2] and the steering angle θ ∈ [ − π 4 , π 4 ] .
Revised: 2 , 0 . 2] and the steering angle θ ∈ [ − π 4 , π 4 ] .

Original: Lastly, we evaluated our approach with a mobile manipulator Fetch (Wise et al., 2016) to perform arm manipulation in order to evaluate scalability of our approach to high-dimensional conﬁguration spaces.
Revised: Lastly, we evaluated our approach with a mobile manipulator Fetch (Wise et al., 2016) to perform arm manipulation in order to evaluate scalability of our approach to high-dimensional conﬁguration spaces.

Original: Figures 2 and 5 show the test environments (unseen by the model while training) for our system.
Revised: Figures 2 and 5 show the test environments (unseen by the model while training) for our system.

Original: Environments shown in Fig.
Revised: Environments shown in Fig.

Original: 2 are inspired by the indoor ofﬁce and household environments.
Revised: 2 are inspired by the indoor ofﬁce and household environments.

Original: Our training data consisted of 20 environments similar to the ones shown in Fig. 2(A)-(D) with dimensions 5 m × 5 m .
Revised: Our training data consisted of 20 environments similar to the ones shown in Fig. 2(A)-(D) with dimensions 5 m × 5 m .

Original: We investigate the scalability of our approach by conducting experiments in environments shown in Fig. 2(E)-(G) with dimensions 25 m × 25 m (much larger than training environments).
Revised: We investigate the scalability of our approach by conducting experiments in environments shown in Fig. 2(E)-(G) with dimensions 25 m × 25 m (much larger than training environments).

Original: To handle such large environments without making any changes to the DNN, we use the standard approach of sliding windows with stride equal to window-width (Tang et al., 2020;
Revised: To handle such large environments without making any changes to the DNN, we use the standard approach of sliding windows with stride equal to window-width (Tang et al., 2020;

Original: Birgui Sekou et al., 2018; Lu et al., 2015; Hou et al., 2016).
Revised: Birgui Sekou et al., 2018; Lu et al., 2015; Hou et al., 2016).

Original: This crops the larger environment into pieces of the size of the training environments.
Revised: This crops the larger environment into pieces of the size of the training environments.

Original: Individual predictions are then combined to generate a set of critical regions for arbitrary large environments.
Revised: Individual predictions are then combined to generate a set of critical regions for arbitrary large environments.

Original: We also evaluate the applicability of our approach to non-holonomic robots in environments shown in Fig. 2(A)-(D).
Revised: We also evaluate the applicability of our approach to non-holonomic robots in environments shown in Fig. 2(A)-(D).

Original: 4. A NALYSIS OF THE R ESULTS
Revised: 4. A NALYSIS OF THE R ESULTS

Original: As discussed in the introduction (Sec. 1), our objective is to show whether 1) state and action abstractions can be derived automatically and 2) whether auto-generated state and action abstractions can be efﬁciently used in a hierarchical planning algorithm.
Revised: As discussed in the introduction (Sec. 1), our objective is to show whether 1) state and action abstractions can be derived automatically and 2) whether auto-generated state and action abstractions can be efﬁciently used in a hierarchical planning algorithm.

Original: Additionally, we also investigate 3) does dynamically updating the heuristic function (line 6 in Alg. 1) improve Alg.
Revised: Additionally, we also investigate 3) does dynamically updating the heuristic function (line 6 in Alg. 1) improve Alg.

Original: 1’s efﬁciency?
Revised: 1’s efﬁciency?

Original: [Equation]
Revised: [Equation]

Original: AN W E L EARN S TATE AND A CTION A BSTRACTIONS ?
Revised: TATE AND A CTION A BSTRACTIONS ?

Original: Our approach learns critical regions for each DOF of the robot.
Revised: Our approach learns critical regions for each DOF of the robot.

Original: Fig.
Revised: Fig.

Original: 4 shows critical regions predicted by our learned model for the hinged robot H .
Revised: 4 shows critical regions predicted by our learned model for the hinged robot H .

Original: We can see that our model was able to identify critical regions in the environment such as doorways and narrow hallways.
Revised: We can see that our model was able to identify critical regions in the environment such as doorways and narrow hallways.

Original: [Figure]
Revised: [Figure]

Original: Fig. 4(a) shows critical regions for orientation of the robot’s base link (captured by DOF θ ).
Revised: Fig. 4(a) shows critical regions for orientation of the robot’s base link (captured by DOF θ ).

Original: The blue regions in the ﬁgure represent the horizontal orientation of the robot and the green regions represent the vertical orientation of the robot.
Revised: The blue regions in the ﬁgure represent the horizontal orientation of the robot and the green regions represent the vertical orientation of the robot.

Original: Fig. 4(b) shows critical regions for the hinge joint ω for the robot H .
Revised: Fig. 4(b) shows critical regions for the hinge joint ω for the robot H .

Original: Here, blue regions show that the network predicted the hinge joint to be ﬂat (close to 0 ◦ ) and green regions represent conﬁgurations where the model predicted ”L” conﬁgurations of the robot ( ω close to 90 ◦ or 270 ◦ ) .
Revised: Here, blue regions show that the network predicted the hinge joint to be ﬂat (close to 0 ◦ ) and green regions represent conﬁgurations where the model predicted ”L” conﬁgurations of the robot ( ω close to 90 ◦ or 270 ◦ ) .

Original: Fig.
Revised: Fig.

Original: 4 shows that our approach was able to predict the correct orientation of the robot accurately most of the time.
Revised: 4 shows that our approach was able to predict the correct orientation of the robot accurately most of the time.

Original: Our approach was able to scale to robots with a high number of degrees of freedom.
Revised: Our approach was able to scale to robots with a high number of degrees of freedom.

Original: Fig.
Revised: Fig.

Original: 5(a) shows one of the test environments used for these experiments and Fig. 5(b) shows the predicted critical regions.
Revised: 5(a) shows one of the test environments used for these experiments and Fig. 5(b) shows the predicted critical regions.

Original: This shows that our model was able to learn critical regions in the environment that can be used to generate efﬁcient abstractions.
Revised: This shows that our model was able to learn critical regions in the environment that can be used to generate efﬁcient abstractions.

Original: We include similar results for other environments in Appendix F.
Revised: We include similar results for other environments in Appendix F.

Original: Now we answer the second question on whether using abstractions to compute motion plans helps improve the planner’s efﬁciency by qualitatively comparing our approach with a few existing sampling-based motion planners.
Revised: Now we answer the second question on whether using abstractions to compute motion plans helps improve the planner’s efﬁciency by qualitatively comparing our approach with a few existing sampling-based motion planners.

Original: [Figure]
Revised: [Figure]

Original: We compare our approach against widely used
Revised: We compare our approach against widely used

Original: SBMPs such as
Revised: SBMPs such as

Original: RRT (LaValle, 1998), PRM (Kavraki et al., 1996), and
Revised: RRT (LaValle, 1998), PRM (Kavraki et al., 1996), and

Original: BiRRT (Kuffner & LaValle, 2000).
Revised: BiRRT (Kuffner & LaValle, 2000).

Original: Fig.
Revised: Fig.

Original: 3 shows the comparison of our approach with other sampling-based motion planners.
Revised: 3 shows the comparison of our approach with other sampling-based motion planners.

Original: The x-axis shows the time limit in seconds and the y-axis shows the percentage of motion planning problems solved in that time limit.
Revised: The x-axis shows the time limit in seconds and the y-axis shows the percentage of motion planning problems solved in that time limit.

Original: For each time limit on x-axis, we randomly generate 100 new motion planning problems to thoroughly test our approach and reduce statistical inconsistencies.
Revised: For each time limit on x-axis, we randomly generate 100 new motion planning problems to thoroughly test our approach and reduce statistical inconsistencies.

Original: Fig.
Revised: Fig.

Original: 3 shows that our approach signiﬁcantly outperforms all of the existing sampling-based motion planners.
Revised: 3 shows that our approach signiﬁcantly outperforms all of the existing sampling-based motion planners.

Original: Specifically for environments C , D , and E , uniform sampling-based approaches were not able to solve a single problem in a time threshold of 600 s .
Revised: Specifically for environments C , D , and E , uniform sampling-based approaches were not able to solve a single problem in a time threshold of 600 s .

Original: Our approach also outperforms the learning-based planner LLP (Molina et al., 2020)
Revised: Our approach also outperforms the learning-based planner LLP (Molina et al., 2020)

Original: (Fig. 3), which uses learned critical regions but does not use state and action abstractions and does not perform  hierarchical planning.
Revised: (Fig. 3), which uses learned critical regions but does not use state and action abstractions and does not perform Generalizable hierarchical planning.

Original: This illustrates the value of learning abstractions and using them efﬁciently for hierarchical planning.
Revised: This illustrates the value of learning abstractions and using them efﬁciently for hierarchical planning.

Original: Similarly, we also evaluate our approach against TogglePRM (Denny & Amato, 2013).
Revised: Similarly, we also evaluate our approach against TogglePRM (Denny & Amato, 2013).

Original: TogglePRM is written in C++ and accepts only discrete SE 2 conﬁguration space for a simple dot robot.
Revised: TogglePRM is written in C++ and accepts only discrete SE 2 conﬁguration space for a simple dot robot.

Original: We created discrete variants of environments shown in Fig.
Revised: We created discrete variants of environments shown in Fig.

Original: 2(A) and 2(B) with a total of 50176 states and compare the total number of nodes sampled.
Revised: 2(A) and 2(B) with a total of 50176 states and compare the total number of nodes sampled.

Original: For 100 random trials, on an average our approach generated 631 ± 278 and 496 ± 175 states compared to TogglePRM which generated 4234 ±and 19234 ± 4345 states for discrete variants of the environments shown in Fig.
Revised: For 100 random trials, on an average our approach generated 631 ± 278 and 496 ± 175 states compared to TogglePRM which generated 4234 ±and 19234 ± 4345 states for discrete variants of the environments shown in Fig.

Original: 2(A) and 2(B) respectively.
Revised: 2(A) and 2(B) respectively.

Original: Our approach was able to outperform TogglePRM since these environments do not have α - (cid:15) -separable passages (Denny & Amato, 2013).
Revised: Our approach was able to outperform TogglePRM since these environments do not have α - (cid:15) -separable passages (Denny & Amato, 2013).

Original: [Figure]
Revised: [Figure]

Original: We carried out two sets of experiments.
Revised: We carried out two sets of experiments.

Original: In the ﬁrst set of experiments, we generated 20 random motion planning problems and solved each problem repeatedly for 10 times while updating the heuristic function.
Revised: In the ﬁrst set of experiments, we generated 20 random motion planning problems and solved each problem repeatedly for 10 times while updating the heuristic function.

Original: We maintained separate copies of high-level heuristic functions for each problem.
Revised: We maintained separate copies of high-level heuristic functions for each problem.

Original: Fig.
Revised: Fig.

Original: 6(a) shows the results for this set of experiments in the environment E (Fig. 2(E)) with the 4 -DOF hinged robot.
Revised: 6(a) shows the results for this set of experiments in the environment E (Fig. 2(E)) with the 4 -DOF hinged robot.

Original: The x-axis shows the planning iteration and the yaxis shows the average time over randomly generated 20 problem instances.
Revised: The x-axis shows the planning iteration and the yaxis shows the average time over randomly generated 20 problem instances.

Original: We can see how planning time reduces drastically once costs for abstract actions are updated.
Revised: We can see how planning time reduces drastically once costs for abstract actions are updated.

Original: In the second set of experiments, we generated 100 random pairs of initial and goal states and computed motion plans for each of them.
Revised: In the second set of experiments, we generated 100 random pairs of initial and goal states and computed motion plans for each of them.

Original: This time, we maintained a single heuristic function across all problems and updated it after each motion planning query.
Revised: This time, we maintained a single heuristic function across all problems and updated it after each motion planning query.

Original: Fig.
Revised: Fig.

Original: 6(b) shows the result of the experiment in the environment E (Fig. 2(E)) with the 4 -DOF hinged robot H .
Revised: 6(b) shows the result of the experiment in the environment E (Fig. 2(E)) with the 4 -DOF hinged robot H .

Original: The x-axis shows the problem number and the y-axis shows the time taken by our approach to compute a solution.
Revised: The x-axis shows the problem number and the y-axis shows the time taken by our approach to compute a solution.

Original: The red line in the plot shows the moving average of planning time.
Revised: The red line in the plot shows the moving average of planning time.

Original: Fig.
Revised: Fig.

Original: 6(b) shwows that dynamically updating the heuristic function for high-level planning helps to increase the efﬁciency of HARP and decrease motion planning times.
Revised: 6(b) shwows that dynamically updating the heuristic function for high-level planning helps to increase the efﬁciency of HARP and decrease motion planning times.

Original: Empirical evaluation using these experiments validates our hypothesis that learning abstractions and effectively using them improves motion planning efﬁciency.
Revised: Empirical evaluation using these experiments validates our hypothesis that learning abstractions and effectively using them improves motion planning efﬁciency.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we presented a probabilistically complete approach HARP, that uses deep learning to identify abstractions for the input conﬁguration space.
Revised: In this paper, we presented a probabilistically complete approach HARP, that uses deep learning to identify abstractions for the input conﬁguration space.

Original: It learns state and action abstractions in a bottom-up fashion and uses them to perform efﬁcient hierarchical robot planning.
Revised: It learns state and action abstractions in a bottom-up fashion and uses them to perform efﬁcient hierarchical robot planning.

Original: We developed a new multi-source bi-directional planning algorithm that uses learned state and action abstractions along with a custom dynamically maintained cost function to generate candidate high-level plans.
Revised: We developed a new multi-source bi-directional planning algorithm that uses learned state and action abstractions along with a custom dynamically maintained cost function to generate candidate high-level plans.

Original: A low-level motion planner reﬁnes these high-level plans into a trajectory that achieves the goal conﬁguration from the initial conﬁguration.
Revised: A low-level motion planner reﬁnes these high-level plans into a trajectory that achieves the goal conﬁguration from the initial conﬁguration.

Original: Our formal framework provides a way to generate sound abstractions that satisfy the downward reﬁnement property for holonomic robots.
Revised: Our formal framework provides a way to generate sound abstractions that satisfy the downward reﬁnement property for holonomic robots.

Original: Our empirical evaluation on a large variety of problem settings shows that our approach is able to signiﬁcantly outperform state-of-the-art sampling and learning-based motion planners.
Revised: Our empirical evaluation on a large variety of problem settings shows that our approach is able to signiﬁcantly outperform state-of-the-art sampling and learning-based motion planners.

Original: Through our empirical evaluation, we show that our approach is robust and can be scaled to large environments and to robots that have high degrees of freedom.
Revised: Through our empirical evaluation, we show that our approach is robust and can be scaled to large environments and to robots that have high degrees of freedom.

Original: Our work presents a foundation for learning high-level, abstractions from low-level trajectories.
Revised: Our work presents a foundation for learning high-level, abstractions from low-level trajectories.

Original: Currently, our approach works for deterministic robot planning problems.
Revised: Currently, our approach works for deterministic robot planning problems.

Original: We aim to extend our approach to support stochastic settings and learn abstractions for task and motion planning problems.
Revised: We aim to extend our approach to support stochastic settings and learn abstractions for task and motion planning problems.

Revised: A CKNOWLEDGMENTS

Revised: We thank Abhyudaya Srinet for his help in implementing a primitive version of the presented work.

Revised: We also thank Kyle Atkinson for his help with creating test environments.

Revised: This work is supported in part by the NSF under grants 1909370 and

Original: A PPENDIX A P RELIMINARIES
Revised: A PPENDIX A P RELIMINARIES

Original: Motion Planning Problem Let X =
Revised: Motion Planning Problem Let X =

Original: X free ∪ X obs be the conﬁguration space of a given robot (LaValle, 2006).
Revised: X free ∪ X obs be the conﬁguration space of a given robot (LaValle, 2006).

Original: Here X free represents the set of conﬁgurations where the robot is not in collision with any obstacle and X obs represents conﬁgurations in collision with an obstacle.
Revised: Here X free represents the set of conﬁgurations where the robot is not in collision with any obstacle and X obs represents conﬁgurations in collision with an obstacle.

Original: Let x i ∈
Revised: Let x i ∈

Original: X free and x g ∈ X free be the initial and goal conﬁgurations of the robot.
Revised: X free and x g ∈ X free be the initial and goal conﬁgurations of the robot.

Original: A motion planning problem is deﬁned as follows:
Revised: A motion planning problem is deﬁned as follows:

Original: Deﬁnition 1.
Revised: Deﬁnition 1.

Original: A motion planning problem M is deﬁned as a 4 -tuple (cid:104)X , u, x i , x g (cid:105) .
Revised: A motion planning problem M is deﬁned as a 4 -tuple (cid:104)X , u, x i , x g (cid:105) .

Original: where X =
Revised: where X =

Original: X free ∪ X obs is the conﬁguration space and x i , x g ∈ X free are the robot’s initial and goal conﬁgurations.
Revised: X free ∪ X obs is the conﬁguration space and x i , x g ∈ X free are the robot’s initial and goal conﬁgurations.

Original: u : X → { 0 , 1 } is a collision function that determines collisions for conﬁgurations: u ( x ) = 1 iff x ∈ X obs.
Revised: u : X → { 0 , 1 } is a collision function that determines collisions for conﬁgurations: u ( x ) = 1 iff x ∈ X obs.

Original: A solution to a motion planning problem is a collision-free trajectory τ : [0 , 1] → X such that τ (0) =
Revised: A solution to a motion planning problem is a collision-free trajectory τ : [0 , 1] → X such that τ (0) =

Original: x i and τ (1) = x g .
Revised: x i and τ (1) = x g .

Original: We abuse the notation to deﬁne membership in a trajectory as follows:
Revised: We abuse the notation to deﬁne membership in a trajectory as follows:

Original: For a conﬁguration x ∈ X , x ∈ τ iff there a exists a t ∈ [0 , 1] such that τ ( t ) = x .
Revised: For a conﬁguration x ∈ X , x ∈ τ iff there a exists a t ∈ [0 , 1] such that τ ( t ) = x .

Original: A trajectory is collision free
Revised: A trajectory is collision free

Original: iff ∀ x ∈ τ, u ( x ) = 0 .
Revised: iff ∀ x ∈ τ, u ( x ) = 0 .

Original: Connectivity A pair of low-level conﬁgurations x i , x j ∈ X is said to be connected iff there exists a collision-free motion plan between x i and x j .
Revised: Connectivity A pair of low-level conﬁgurations x i , x j ∈ X is said to be connected iff there exists a collision-free motion plan between x i and x j .

Original: We represent this using a connectivity function
Revised: We represent this using a connectivity function

Original: C : X free ×X free → { 0 , 1 } : C ( x i , x j )
Revised: C : X free ×X free → { 0 , 1 } : C ( x i , x j )

Original: = 1 iff x i and x j are connected.
Revised: = 1 iff x i and x j are connected.

Original: Intuitively, the connectivity function C represents Euclidean connectivity in X free .
Revised: Intuitively, the connectivity function C represents Euclidean connectivity in X free .

Original: This is equivalent to path connectivity in conﬁguration space for holonomic robots as each degree of freedom can be controlled independently.
Revised: This is equivalent to path connectivity in conﬁguration space for holonomic robots as each degree of freedom can be controlled independently.

Original: However, this may not be the case for non-holonomic robots as some of the motion plans may not be realizable due to their motion constraints.
Revised: However, this may not be the case for non-holonomic robots as some of the motion plans may not be realizable due to their motion constraints.

Original: We use this to deﬁne strong connectivity for the set of low-level conﬁgurations as follows:
Revised: We use this to deﬁne strong connectivity for the set of low-level conﬁgurations as follows:

Original: Deﬁnition 2.
Revised: Deﬁnition 2.

Original: Let ¯ X ⊆
Revised: Let ¯ X ⊆

Original: X free be a set of conﬁgurations.
Revised: X free be a set of conﬁgurations.

Original: ¯ X is a strongly connected set iff for every pair of conﬁgurations ( x i ,
Revised: ¯ X is a strongly connected set iff for every pair of conﬁgurations ( x i ,

Original: x j ) ∈
Revised: x j ) ∈

Original: X free ×X free, C ( x i , x j ) =
Revised: X free ×X free, C ( x i , x j ) =

Original: and there exists a trajectory τ ij such that τ ij (0) =
Revised: and there exists a trajectory τ ij such that τ ij (0) =

Original: x i , τ ij (1) =
Revised: x i , τ ij (1) =

Original: x j , and ∀ t ∈ [0 , 1] , τ ij ( t ) ∈ ¯ X ,
Revised: x j , and ∀ t ∈ [0 , 1] , τ ij ( t ) ∈ ¯ X ,

Original: Critical Regions Our approach uses critical regions (CRs) to generate abstractions.
Revised: Critical Regions Our approach uses critical regions (CRs) to generate abstractions.

Original: Intuitively, critical regions are regions in the conﬁguration space that have a high density of valid motion plans passing through them for the given class of motion planning problems.
Revised: Intuitively, critical regions are regions in the conﬁguration space that have a high density of valid motion plans passing through them for the given class of motion planning problems.

Original: Molina et al.
Revised: Molina et al.

Original: (2020) deﬁne critical regions as follows:
Revised: (2020) deﬁne critical regions as follows:

Original: Deﬁnition 3.
Revised: Deﬁnition 3.

Original: Given a robot R , a conﬁguration space X , and a class of motion planning problems M , the measure of criticality of a Lebesgue-measurable open set r ⊆
Revised: Given a robot R , a conﬁguration space X , and a class of motion planning problems M , the measure of criticality of a Lebesgue-measurable open set r ⊆

Original: X is deﬁned as lim s n → + r f ( r ) v ( s n ) , where f ( r ) is the fraction of observed motion plans solving tasks from M that pass through s n , v ( s n ) is the measure of s n under a reference density (usually uniform), and → + denotes the limit from above along any sequence { s n } of sets containing r ( r ⊆ s n , ∀ n ).
Revised: X is deﬁned as lim s n → + r f ( r ) v ( s n ) , where f ( r ) is the fraction of observed motion plans solving tasks from M that pass through s n , v ( s n ) is the measure of s n under a reference density (usually uniform), and → + denotes the limit from above along any sequence { s n } of sets containing r ( r ⊆ s n , ∀ n ).

Original: Beam Search Lowerre (1976) introduced beam search as an optimization over breadth-ﬁrst search (BFS) that explores the state space by expanding only a subset of nodes to compute a path from one node to another node in the graph.
Revised: Beam Search Lowerre (1976) introduced beam search as an optimization over breadth-ﬁrst search (BFS) that explores the state space by expanding only a subset of nodes to compute a path from one node to another node in the graph.

Original: Beam search prunes the fringe to reduce the size of OPEN set.
Revised: Beam search prunes the fringe to reduce the size of OPEN set.

Original: We include pseudocode for the beam search in Appendix C.
Revised: We include pseudocode for the beam search in Appendix C.

Original: B H IERARCHICAL S TATE AND A CTION A BSTRACTIONS
Revised: B H IERARCHICAL S TATE AND A CTION A BSTRACTIONS

Original: We begin describing our formal framework with an example.
Revised: We begin describing our formal framework with an example.

Original: Fig. 1(b) shows a set of critical regions for a given environment.
Revised: Fig. 1(b) shows a set of critical regions for a given environment.

Original: Ideally, we would like to predict these critical regions and generate a state and action abstraction similar to the one shown in Fig. 1(c).
Revised: Ideally, we would like to predict these critical regions and generate a state and action abstraction similar to the one shown in Fig. 1(c).

Original: The state abstraction shown in Fig.
Revised: The state abstraction shown in Fig.

Original: 1(c), similar to a Voronoi diagram, generates cells around each critical region such that the distance from each point in a cell to its corresponding critical regions is less than that from every other critical region.
Revised: 1(c), similar to a Voronoi diagram, generates cells around each critical region such that the distance from each point in a cell to its corresponding critical regions is less than that from every other critical region.

Original: We call this structure a region-based Voronoi diagram (RBVD) .
Revised: We call this structure a region-based Voronoi diagram (RBVD) .

Original: Each cell in this regionbased Voronoi diagram is considered an abstract state and transitions between these Voronoi cells (abstract states) deﬁne abstract actions.
Revised: Each cell in this regionbased Voronoi diagram is considered an abstract state and transitions between these Voronoi cells (abstract states) deﬁne abstract actions.

Original: Let ρ be the set of critical regions for the given conﬁguration space X .
Revised: Let ρ be the set of critical regions for the given conﬁguration space X .

Original: First we introduce distance metrics d c and d r .
Revised: First we introduce distance metrics d c and d r .

Original: Here, d c deﬁnes distance between a low-level conﬁguration x ∈ X and a critical region r ∈ ρ such that d c ( x, r ) =
Revised: Here, d c deﬁnes distance between a low-level conﬁguration x ∈ X and a critical region r ∈ ρ such that d c ( x, r ) =

Original: min x i ∈
Revised: min x i ∈

Original: r d ( x, x i ) and d r deﬁnes the distance between two critical regions r 1 , r 2 such that the distance d r = min x i ∈
Revised: r d ( x, x i ) and d r deﬁnes the distance between two critical regions r 1 , r 2 such that the distance d r = min x i ∈

Original: r
Revised: r

Original: 1 ,x j ∈ r 2 d ( x i , x j ) where d is the Euclidean distance.
Revised: 1 ,x j ∈ r 2 d ( x i , x j ) where d is the Euclidean distance.

Original: Now, we deﬁne region-based Voronoi diagram as follows:
Revised: Now, we deﬁne region-based Voronoi diagram as follows:

Original: Deﬁnition 4.
Revised: Deﬁnition 4.

Original: Let ρ = { r 1 , ..., r k } be a set of critical regions for the conﬁguration space X .
Revised: Let ρ = { r 1 , ..., r k } be a set of critical regions for the conﬁguration space X .

Original: A region-based Voronoi diagram (RBVD) is a partition Ψ( ρ, X )
Revised: A region-based Voronoi diagram (RBVD) is a partition Ψ( ρ, X )

Original: = { ψ 1 , ..., ψ m } of X such that for every ψ i ∈
Revised: = { ψ 1 , ..., ψ m } of X such that for every ψ i ∈

Original: Ψ there exists a critical regions r such that forall x ∈ ψ i and forall r j (cid:54) =
Revised: Ψ there exists a critical regions r such that forall x ∈ ψ i and forall r j (cid:54) =

Original: r , d c ( x, r ) ≤ d c ( x, r j ) and each ψ i is strongly connected.
Revised: r , d c ( x, r ) ≤ d c ( x, r j ) and each ψ i is strongly connected.

Original: State Abstraction
Revised: State Abstraction

Original: We deﬁne abstract states as the Voronoi cells of an RBVD.
Revised: We deﬁne abstract states as the Voronoi cells of an RBVD.

Original: Given an RBVD Ψ , labelling function (cid:96) : Ψ → S maps each cell in the RBVD to a unique abstract state s ∈ S where |S| = | Ψ | .
Revised: Given an RBVD Ψ , labelling function (cid:96) : Ψ → S maps each cell in the RBVD to a unique abstract state s ∈ S where |S| = | Ψ | .

Original: We use this to deﬁne the state abstraction function α as follows:
Revised: We use this to deﬁne the state abstraction function α as follows:

Original: Deﬁnition 5.
Revised: Deﬁnition 5.

Original: Let R be the robot and X = X free ∪ X obs be the conﬁguration space of the robot R with set of critical regions ρ .
Revised: Let R be the robot and X = X free ∪ X obs be the conﬁguration space of the robot R with set of critical regions ρ .

Original: Let Ψ( ρ, X ) = { ψ 1 , ..ψ k } be an RBVD for the robot R , conﬁguration space X , and the set of critical regions ρ and let
Revised: Let Ψ( ρ, X ) = { ψ 1 , ..ψ k } be an RBVD for the robot R , conﬁguration space X , and the set of critical regions ρ and let

Original: S = { s 1 , .., s k } be a set of high-level, abstract states.
Revised: S = { s 1 , .., s k } be a set of high-level, abstract states.

Original: We deﬁne abstraction function α : X free → S such that α ( x ) =
Revised: We deﬁne abstraction function α : X free → S such that α ( x ) =

Original: s where x ∈ ψ and (cid:96) ( ψ )
Revised: s where x ∈ ψ and (cid:96) ( ψ )

Original: = s .
Revised: = s .

Original: We extend this notation to deﬁne membership in abstract states as follows:
Revised: We extend this notation to deﬁne membership in abstract states as follows:

Original: Given a conﬁguration space X = X free ∪ X obs and its set of abstract states S as deﬁned above, a conﬁguration x ∈ X free is said to be a member of an abstract state s ∈ S (denoted x ∈ s )
Revised: Given a conﬁguration space X = X free ∪ X obs and its set of abstract states S as deﬁned above, a conﬁguration x ∈ X free is said to be a member of an abstract state s ∈ S (denoted x ∈ s )

Original: iff α ( x ) = s .
Revised: iff α ( x ) = s .

Original: We also extend the notion of strong connectivity to abstract states as follows:
Revised: We also extend the notion of strong connectivity to abstract states as follows:

Original: An abstract state s ∈ S is strongly connected iff (cid:96) − 1 ( s ) is strongly connected.
Revised: An abstract state s ∈ S is strongly connected iff (cid:96) − 1 ( s ) is strongly connected.

Original: We now deﬁne adjacency for Voronoi cells in a regionbased Voronoi diagram as follows.
Revised: We now deﬁne adjacency for Voronoi cells in a regionbased Voronoi diagram as follows.

Original: Recall that C denotes Euclidean connectivity for conﬁgurations.
Revised: Recall that C denotes Euclidean connectivity for conﬁgurations.

Original: Deﬁnition 6.
Revised: Deﬁnition 6.

Original: Let ψ i , ψ j be Voronoi cells of an RBVD Ψ .
Revised: Let ψ i , ψ j be Voronoi cells of an RBVD Ψ .

Original: Voronoi cells ψ i and ψ j are adjacent iff there exist conﬁgurations x
Revised: Voronoi cells ψ i and ψ j are adjacent iff there exist conﬁgurations x

Original: i , x j such that x i ∈ ψ
Revised: i , x j such that x i ∈ ψ

Original: i , x j ∈ ψ j , C ( x i , x j ) = 1 , and there exists a trajectory τ between x i and x j such that ∀ t ∈ [0 , 1] , τ ( t ) ∈ ψ i or τ ( t ) ∈ ψ j .
Revised: i , x j ∈ ψ j , C ( x i , x j ) = 1 , and there exists a trajectory τ between x i and x j such that ∀ t ∈ [0 , 1] , τ ( t ) ∈ ψ i or τ ( t ) ∈ ψ j .

Original: We extend the above deﬁnition to deﬁne the neighborhood for an abstract state.
Revised: We extend the above deﬁnition to deﬁne the neighborhood for an abstract state.

Original: Two abstract states s i , s j ∈ S are neighbors iff (cid:96) − 1 ( s i ) and (cid:96) − 1 ( s j ) are adjacent.
Revised: Two abstract states s i , s j ∈ S are neighbors iff (cid:96) − 1 ( s i ) and (cid:96) − 1 ( s j ) are adjacent.

Original: We deﬁne abstract actions as transitions between abstract states.
Revised: We deﬁne abstract actions as transitions between abstract states.

Original: Let S be the set of abstract states.
Revised: Let S be the set of abstract states.

Original: We deﬁne the set of abstract actions
Revised: We deﬁne the set of abstract actions

Original: A using S such that A
Revised: A using S such that A

Original: = { a ij |∀ ( s i , s j ) ∈ S × S} .
Revised: = { a ij |∀ ( s i , s j ) ∈ S × S} .

Original: We now use this formulation of RBVD and state abstraction to prove the soundness of the generated abstractions .
Revised: We now use this formulation of RBVD and state abstraction to prove the soundness of the generated abstractions .

Original: Theorem B.1.
Revised: Theorem B.1.

Original: Let X =
Revised: Let X =

Original: X free ∪X obs be a conﬁguration space and ρ be a set of critical regions for
Revised: X free ∪X obs be a conﬁguration space and ρ be a set of critical regions for

Original: X .
Revised: X .

Original: Let Ψ be an RBVD for the critical regions ρ and the conﬁguration space X
Revised: Let Ψ be an RBVD for the critical regions ρ and the conﬁguration space X

Original: and let S be the set of abstract states corresponding to Ψ with a mapping function (cid:96) .
Revised: and let S be the set of abstract states corresponding to Ψ with a mapping function (cid:96) .

Original: Let x 0 and x g be the initial and goal conﬁgurations of a holonomic robot R .
Revised: Let x 0 and x g be the initial and goal conﬁgurations of a holonomic robot R .

Original: If every state s ∈ S is strongly connected and there exists a sequence of abstract states P = (cid:104) s ψ 0 , ..., s ψ g (cid:105) such that x 0 ∈ s ψ 0 , x g ∈ s ψ g , and all consecutive states s ψ i , s ψ i +1 ∈ P are neighbors, then there exists a motion plan for R that reaches x g from xwith a trajectory τ such that τ (0) =
Revised: If every state s ∈ S is strongly connected and there exists a sequence of abstract states P = (cid:104) s ψ 0 , ..., s ψ g (cid:105) such that x 0 ∈ s ψ 0 , x g ∈ s ψ g , and all consecutive states s ψ i , s ψ i +1 ∈ P are neighbors, then there exists a motion plan for R that reaches x g from xwith a trajectory τ such that τ (0) =

Original: x 0 , τ (1) = x g , and ∀ x i ∈ τ, x i ∈ s ψ k such that s ψ k ∈ P .
Revised: x 0 , τ (1) = x g , and ∀ x i ∈ τ, x i ∈ s ψ k such that s ψ k ∈ P .

Original: Theorem B.1 proves that the computed abstractions would be sound as well as satisfy downward reﬁnement property for holonomic robots.
Revised: Theorem B.1 proves that the computed abstractions would be sound as well as satisfy downward reﬁnement property for holonomic robots.

Original: The proof does not hold for non-holonomic robots as the low-level trajectories may not be realizable given their motion constraints.
Revised: The proof does not hold for non-holonomic robots as the low-level trajectories may not be realizable given their motion constraints.

Original: However, the algorithm developed below is probabilistically complete for all robots and performed well for non-holonomic robots in our empirical evaluation.
Revised: However, the algorithm developed below is probabilistically complete for all robots and performed well for non-holonomic robots in our empirical evaluation.

Original: C V ANILLA B EAM S EARCH
Revised: C V ANILLA B EAM S EARCH

Original: D M ULTI - SOURCE B I - DIRECTIONAL B EAM S EARCH
Revised: D M ULTI - SOURCE B I - DIRECTIONAL B EAM S EARCH

Original: E L EARNING TO P REDICT C RITICAL R EGIONS
Revised: E L EARNING TO P REDICT C RITICAL R EGIONS

Original: We now present our approach for learning a model Φ that predicts critical regions for a given environment.
Revised: We now present our approach for learning a model Φ that predicts critical regions for a given environment.

Original: We ﬁrst explain how our approach is able to generate a robot-speciﬁc architecture of the network and then describe the training process.
Revised: We ﬁrst explain how our approach is able to generate a robot-speciﬁc architecture of the network and then describe the training process.

Original: D ERIVING R OBOT S PECIFIC N ETWORK A RCHITECTURES
Revised: D ERIVING R OBOT S PECIFIC N ETWORK A RCHITECTURES

Original: We use the standard fully convolutional UNet architecture (Ronneberger et al., 2015) as our base network.
Revised: We use the standard fully convolutional UNet architecture (Ronneberger et al., 2015) as our base network.

Original: Fig.
Revised: Fig.

Original: 7 shows the overall architecture of our network alongside its input and label format.
Revised: 7 shows the overall architecture of our network alongside its input and label format.

Original: We use the robot’s geometry and its number of DOFs to derive a robot speciﬁc architecture as follows:
Revised: We use the robot’s geometry and its number of DOFs to derive a robot speciﬁc architecture as follows:

Original: Let n be the number of DOFs of the robot and let k be the number of DOFs that are not determined by the location of the robot’s end-effector in the workspace.
Revised: Let n be the number of DOFs of the robot and let k be the number of DOFs that are not determined by the location of the robot’s end-effector in the workspace.

Original: For manipulation problems, we consider gripper of the robot as the its end-effector and for navigational problems, we consider the robot’s base link as its end effector.
Revised: For manipulation problems, we consider gripper of the robot as the its end-effector and for navigational problems, we consider the robot’s base link as its end effector.

Original: First, we use these parameters to update the base UNet architecture.
Revised: First, we use these parameters to update the base UNet architecture.

Original: We use the last layer of the base architecture to predict critical regions for the end-effector’s location and include k additional convolutional layers to predict critical regions for each k DOFs that are not determined by the location of the robot’s end effector.
Revised: We use the last layer of the base architecture to predict critical regions for the end-effector’s location and include k additional convolutional layers to predict critical regions for each k DOFs that are not determined by the location of the robot’s end effector.

Original: The input to the network is a tensor of dimension four.
Revised: The input to the network is a tensor of dimension four.

Original: The size of the ﬁrst three dimensions of the input tensor depends on the number of bins used to discretize the environment (which can be arbitrary).
Revised: The size of the ﬁrst three dimensions of the input tensor depends on the number of bins used to discretize the environment (which can be arbitrary).

Original: The number of channels in the input tensor is determined using the parameter n .
Revised: The number of channels in the input tensor is determined using the parameter n .

Original: If the robot has n DOFs, then the input tensor would have a total of n + 1 channels.
Revised: If the robot has n DOFs, then the input tensor would have a total of n + 1 channels.

Original: The ﬁrst channel in the input represents the occupancy matrix of the environment.
Revised: The ﬁrst channel in the input represents the occupancy matrix of the environment.

Original: It is generated by performing a raster scan of the environment.
Revised: It is generated by performing a raster scan of the environment.

Original: The rest of the n channels represent goal values for each DOF of the robot -- one for each DOF of the robot.
Revised: The rest of the n channels represent goal values for each DOF of the robot -- one for each DOF of the robot.

Original: Similarly, each label is a tensor of dimension four.
Revised: Similarly, each label is a tensor of dimension four.

Original: The size of the ﬁrst three dimensions is similar to the input tensor.
Revised: The size of the ﬁrst three dimensions is similar to the input tensor.

Original: The number of channels in the label tensor is also computed using the robot’s geometry.
Revised: The number of channels in the label tensor is also computed using the robot’s geometry.

Original: For a robot with k DOFs that are not determined by the location of robot’s end effector in the workspace, the label tensor would have a total of k + 1 channels.
Revised: For a robot with k DOFs that are not determined by the location of robot’s end effector in the workspace, the label tensor would have a total of k + 1 channels.

Original: The ﬁrst channel represents critical regions for the end-effector’s location in the workspace and the rest of the k channels repre- sent critical regions for the k DOFs that are not determined by this location -- one channel for each of the k DOFs of the robot.
Revised: The ﬁrst channel represents critical regions for the end-effector’s location in the workspace and the rest of the k channels repre- sent critical regions for the k DOFs that are not determined by this location -- one channel for each of the k DOFs of the robot.

Original: E.g, consider a 5 -DOF hinged robot.
Revised: E.g, consider a 5 -DOF hinged robot.

Original: The robot’s 5 DOFs are ( x, y, z, θ, ω ) where x , y , and z represent the location of the robot’s base link in the workspace, θ represents the rotation of the base link, and ω represents the hinged angle.
Revised: The robot’s 5 DOFs are ( x, y, z, θ, ω ) where x , y , and z represent the location of the robot’s base link in the workspace, θ represents the rotation of the base link, and ω represents the hinged angle.

Original: So for this robot, n would equal to 5 and k would equal toas only the base rotation θ and the hinged angle ω are not determined by the location of the robot’s end-effector (base link in this case) in the workspace.
Revised: So for this robot, n would equal to 5 and k would equal toas only the base rotation θ and the hinged angle ω are not determined by the location of the robot’s end-effector (base link in this case) in the workspace.

Original: So according to the previous discussion, the network would contain k = 2 additional layers to predict critical regions for θ and ω .
Revised: So according to the previous discussion, the network would contain k = 2 additional layers to predict critical regions for θ and ω .

Original: The input tensor would have a total of n + 1 = 6 channels and the label tensor would have a total of k + 1 =channels.
Revised: The input tensor would have a total of n + 1 = 6 channels and the label tensor would have a total of k + 1 =channels.

Original: T RAINING THE N ETWORK
Revised: T RAINING THE N ETWORK

Original: The layer predicting critical regions for the end-effector’s locations in the workspace, ( L l ) , uses the sigmoid activation as the task is similar to element-wise classiﬁcation.
Revised: The layer predicting critical regions for the end-effector’s locations in the workspace, ( L l ) , uses the sigmoid activation as the task is similar to element-wise classiﬁcation.

Original: The layers predicting critical regions for the rest of the degrees of freedom that are not determined by the end-effector’s location, ( L i ) use the softmax activation as the task corresponds to multi-class classiﬁcation.
Revised: The layers predicting critical regions for the rest of the degrees of freedom that are not determined by the end-effector’s location, ( L i ) use the softmax activation as the task corresponds to multi-class classiﬁcation.

Original: The loss function is deﬁned as follows:
Revised: The loss function is deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where, L L 1 is weighted log loss and L L i is softmax cross entropy loss for i th degree of freedom not determined by end-effecot’s location in the workspace.
Revised: where, L L 1 is weighted log loss and L L i is softmax cross entropy loss for i th degree of freedom not determined by end-effecot’s location in the workspace.

Original: We use ADAM Optimizer (Kingma & Ba, 2014) with learning rate 10 − 4 .
Revised: We use ADAM Optimizer (Kingma & Ba, 2014) with learning rate 10 − 4 .

Original: We implement the UNet architecture shown in the appendix using
Revised: We implement the UNet architecture shown in the appendix using

Original: Tensorﬂow Abadi et al.
Revised: Tensorﬂow Abadi et al.

Original: We train the network for 50 , 000 epochs.
Revised: We train the network for 50 , 000 epochs.

Original: G ENERATING T RAINING D ATA
Revised: G ENERATING T RAINING D ATA

Original: We use 20 training environments to generate training data for navigational problems (robots R , Car, and H ) and 6 training environments for manipulation problems (Fetch robot).
Revised: We use 20 training environments to generate training data for navigational problems (robots R , Car, and H ) and 6 training environments for manipulation problems (Fetch robot).

Original: To generate training data for each training environment E , we randomly sample a set of 100 conﬁgurations G , which would serve as goal states for the motion planning problems.
Revised: To generate training data for each training environment E , we randomly sample a set of 100 conﬁgurations G , which would serve as goal states for the motion planning problems.

Original: For each goal conﬁguration g i ∈ G , we sample a set of 50 initial states I .
Revised: For each goal conﬁguration g i ∈ G , we sample a set of 50 initial states I .

Original: We use an off-the-shelf motion planner to compute motion plans for these inital and goal states and combined solutions to generate critical regions for each goal state.
Revised: We use an off-the-shelf motion planner to compute motion plans for these inital and goal states and combined solutions to generate critical regions for each goal state.

Original: We use these motion plans to compute critical regions for the given pair of environment E and the goal conﬁguration g using the Def. 3.
Revised: We use these motion plans to compute critical regions for the given pair of environment E and the goal conﬁguration g using the Def. 3.

Original: We use OpeanRAVE robot simulator (Diankov, 2010) and
Revised: We use OpeanRAVE robot simulator (Diankov, 2010) and

Original: OMPL’s implementation of BiRRT (Kuffner & LaValle, 2000) to generate the training data.
Revised: OMPL’s implementation of BiRRT (Kuffner & LaValle, 2000) to generate the training data.

Original: To generate the input vector, we discretize the environment into n d bins.
Revised: To generate the input vector, we discretize the environment into n d bins.

Original: This also implies that the degrees of freedom of the robot that are determined by the robot’s end-effecotr’s location in the workspace are also discretized into n d bins.
Revised: This also implies that the degrees of freedom of the robot that are determined by the robot’s end-effecotr’s location in the workspace are also discretized into n d bins.

Original: We discretize the rest of the degrees of freedom that are not determined by the robot’s end-effecotr’s location into p bins to generate input and label tensors according to the discussion in Sec.
Revised: We discretize the rest of the degrees of freedom that are not determined by the robot’s end-effecotr’s location into p bins to generate input and label tensors according to the discussion in Sec.

Original: E. We augment the computed tensors by rotating them by 90 ◦ , 180 ◦ , and 270 ◦ to obtain more training samples.
Revised: E. We augment the computed tensors by rotating them by 90 ◦ , 180 ◦ , and 270 ◦ to obtain more training samples.

Original: We also omit an additional dimension from the tensors for navigational problems as we ﬁx the robot’s
Revised: We also omit an additional dimension from the tensors for navigational problems as we ﬁx the robot’s

Original: z -axis for these problems.
Revised: z -axis for these problems.

Original: The table below shows the training details for each robot.
Revised: The table below shows the training details for each robot.

Original: [Table]
Revised: [Table]

Original: F R ESULTS F. 3 -DOF R ECTANGULAR AND C AR R OBOTS
Revised: F R ESULTS F. 3 -DOF R ECTANGULAR AND C AR R OBOTS

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]