├── README.md ├── model ├── __init__.py └── model.py ├── utils ├── __init__.py ├── utils.py └── plot.py ├── algorithm ├── alg_config.py ├── __init__.py ├── search_tree.py └── tsa.py ├── environment ├── __init__.py ├── env_config.py └── maze_env.py ├── trained_models ├── NEXT_2d.pt └── NEXT_3d.pt ├── maze_files ├── mazes_15_2_3000.npz └── mazes_15_3_3000.npz ├── LICENSE ├── .gitignore └── main.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # NEXT-learning-to-plan -------------------------------------------------------------------------------- /model/__init__.py: -------------------------------------------------------------------------------- 1 | from .model import * -------------------------------------------------------------------------------- /utils/__init__.py: -------------------------------------------------------------------------------- 1 | from .utils import * 2 | from .plot import * -------------------------------------------------------------------------------- /algorithm/alg_config.py: -------------------------------------------------------------------------------- 1 | # RRT resolution 2 | RRT_EPS = 5e-2 3 | 4 | -------------------------------------------------------------------------------- /environment/__init__.py: -------------------------------------------------------------------------------- 1 | from .env_config import * 2 | from .maze_env import * -------------------------------------------------------------------------------- /algorithm/__init__.py: -------------------------------------------------------------------------------- 1 | from .search_tree import * 2 | from .tsa import * 3 | from .alg_config import * -------------------------------------------------------------------------------- /trained_models/NEXT_2d.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NeurEXT/NEXT-learning-to-plan/HEAD/trained_models/NEXT_2d.pt -------------------------------------------------------------------------------- /trained_models/NEXT_3d.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NeurEXT/NEXT-learning-to-plan/HEAD/trained_models/NEXT_3d.pt -------------------------------------------------------------------------------- /maze_files/mazes_15_2_3000.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NeurEXT/NEXT-learning-to-plan/HEAD/maze_files/mazes_15_2_3000.npz -------------------------------------------------------------------------------- /maze_files/mazes_15_3_3000.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NeurEXT/NEXT-learning-to-plan/HEAD/maze_files/mazes_15_3_3000.npz -------------------------------------------------------------------------------- /environment/env_config.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from algorithm import RRT_EPS 3 | 4 | STICK_LENGTH = 1.5 * 2 / 15 5 | LIMITS = np.array([1., 1., 8.*RRT_EPS]) -------------------------------------------------------------------------------- /utils/utils.py: -------------------------------------------------------------------------------- 1 | import os 2 | import numpy as np 3 | import torch 4 | import random 5 | 6 | def mkdir_if_not_exist(dir_name): 7 | if not os.path.exists(dir_name): 8 | os.makedirs(dir_name) 9 | 10 | def set_random_seed(seed): 11 | np.random.seed(seed) 12 | torch.manual_seed(seed) 13 | random.seed(seed) 14 | 15 | def load_model(model, file, use_cuda=True): 16 | if use_cuda: 17 | model.load_state_dict(torch.load(file)) 18 | else: 19 | model.load_state_dict(torch.load(file, map_location=lambda storage, loc: storage)) 20 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 NeurEXT 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | -------------------------------------------------------------------------------- /utils/plot.py: -------------------------------------------------------------------------------- 1 | import matplotlib 2 | from matplotlib import cm 3 | import matplotlib.pyplot as plt 4 | import matplotlib.patches as patches 5 | import numpy as np 6 | 7 | from environment import MazeEnv 8 | 9 | def draw_node(state, color, radius_scale=1., dim=2, face=False): 10 | if dim == 2: 11 | facecolor = 'none' 12 | if face: 13 | facecolor = color 14 | circle = patches.Circle(tuple(state+1.0), radius=0.02 * radius_scale, edgecolor=color, facecolor=facecolor) 15 | plt.gca().add_patch(circle) 16 | 17 | elif dim == 3: 18 | a, b = MazeEnv._end_points(state) 19 | plt.gca().add_patch(patches.ConnectionPatch(a+1.0, b+1.0, 'data', arrowstyle="-", linewidth=2, color=color)) 20 | plt.gca().add_patch(patches.Circle(a+1.0, radius=0.02 * radius_scale, edgecolor=color, facecolor=color)) 21 | 22 | def draw_edge(state0, state1, color, dim=2, style='-'): 23 | path = patches.ConnectionPatch(tuple(state0[:2]+1.0), tuple(state1[:2]+1.0), 'data', arrowstyle=style, color=color) 24 | plt.gca().add_patch(path) 25 | 26 | def plot_tree(states, parents, problem, index=0, edge_classes=None): 27 | states = states 28 | environment_map = problem["map"] 29 | init_state = problem["init_state"] 30 | goal_state = problem["goal_state"] 31 | dim = init_state.size 32 | 33 | fig = plt.figure(figsize=(4,4)) 34 | 35 | rect = patches.Rectangle((0.0, 0.0), 2.0, 2.0, linewidth=1, edgecolor='black', facecolor='none') 36 | plt.gca().add_patch(rect) 37 | 38 | map_width = environment_map.shape 39 | d_x = 2.0 / map_width[0] 40 | d_y = 2.0 / map_width[1] 41 | for i in range(map_width[0]): 42 | for j in range(map_width[1]): 43 | if environment_map[i,j] > 0: 44 | rect = patches.Rectangle((d_x*i, d_y*j), d_x, d_y, linewidth=1, edgecolor='#253494', facecolor='#253494') 45 | plt.gca().add_patch(rect) 46 | 47 | for i in range(len(states)-1): 48 | draw_node(states[i+1], '#fdbe85', dim=dim) 49 | 50 | if edge_classes is None: 51 | draw_edge(states[i+1], states[parents[i+1]], 'green', dim=dim) 52 | else: 53 | if edge_classes[i+1] == True: 54 | draw_edge(states[i+1], states[parents[i+1]], 'blue', dim=dim) 55 | else: 56 | draw_edge(states[i+1], states[parents[i+1]], 'green', dim=dim) 57 | 58 | 59 | draw_node(init_state, '#e6550d', dim=dim, face=True) 60 | draw_node(goal_state, '#a63603', dim=dim, face=True) 61 | 62 | plt.axis([0.0, 2.0, 0.0, 2.0]) 63 | plt.axis('off') 64 | plt.axis('square') 65 | 66 | plt.subplots_adjust(left=-0., right=1.0, top=1.0, bottom=-0.) 67 | 68 | plt.show() 69 | -------------------------------------------------------------------------------- /algorithm/search_tree.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | from .alg_config import RRT_EPS 4 | import torch 5 | 6 | class SearchTree: 7 | def __init__(self, env, root, model=None, dim=2): 8 | self.states = np.array([root]) 9 | self.parents = [None] 10 | self.rewired_parents = [None] 11 | self.expanded_by_rrt = [None] 12 | self.freesp = [True] 13 | self.costs = [0.] 14 | self.path_lengths = [-1] 15 | self.cumulated_collision_checks = [0] 16 | self.in_goal_region = [False] 17 | 18 | # for global exploration 19 | self.non_terminal_states = np.array([root]) 20 | self.non_terminal_idxes = [0] 21 | 22 | if model is not None: 23 | # Multi-armed bandit stats 24 | self.visits = [1] 25 | self.state_values = [model.pred_value(root)] 26 | 27 | # kernel regression stats 28 | self.w = [compute_w(env, self, idx=0)] 29 | self.w_sum = self.w[0] 30 | 31 | def update_collision_checks(search_tree, collision_checks): 32 | search_tree.cumulated_collision_checks.append(collision_checks) 33 | 34 | def rewire_to(search_tree, child_idx, new_parent_idx): 35 | search_tree.rewired_parents[child_idx] = new_parent_idx 36 | 37 | def set_cost(search_tree, idx, new_cost): 38 | search_tree.costs[idx] = new_cost 39 | 40 | # Update path length if a path is found. 41 | if idx == -1 and search_tree.in_goal_region[-1]: 42 | if search_tree.path_lengths[-1] < 0 or \ 43 | search_tree.path_lengths[-1] > new_cost: 44 | search_tree.path_lengths[-1] = new_cost 45 | 46 | def insert_new_state(env, search_tree, state, model, parent_idx, no_collision, \ 47 | done, expanded_by_rrt=False, use_GP=False): 48 | search_tree.states = np.append(search_tree.states, [state], axis=0) 49 | search_tree.parents.append(parent_idx) 50 | search_tree.rewired_parents.append(parent_idx) 51 | search_tree.expanded_by_rrt.append(expanded_by_rrt) 52 | search_tree.freesp.append(no_collision) 53 | search_tree.in_goal_region.append(done) 54 | 55 | # Will be updated in post-processing. 56 | search_tree.path_lengths.append(search_tree.path_lengths[-1]) 57 | search_tree.costs.append(-1) 58 | 59 | if no_collision and (not done): 60 | search_tree.non_terminal_states = np.append( \ 61 | search_tree.non_terminal_states, [state], axis=0) 62 | search_tree.non_terminal_idxes.append(search_tree.states.shape[0]-1) 63 | 64 | if model is not None: 65 | state_value = model.pred_value(state) 66 | search_tree.visits[parent_idx] += 1 67 | search_tree.visits.append(0) 68 | search_tree.state_values.append(state_value) 69 | 70 | search_tree.w_sum -= search_tree.w[parent_idx] 71 | parent_w = compute_w(env, search_tree, idx=parent_idx) 72 | search_tree.w[parent_idx] = parent_w 73 | search_tree.w_sum += parent_w 74 | 75 | w = compute_w(env, search_tree, state=state) 76 | search_tree.w.append(w) 77 | search_tree.w_sum += w 78 | 79 | return search_tree.states.shape[0]-1 80 | 81 | def state_kernel(env, state_A, state_B): 82 | diff = env.distance(state_A, state_B) / RRT_EPS 83 | kernel = np.exp( - (diff**2) * 1.) 84 | 85 | return kernel 86 | 87 | def compute_w(env, search_tree, idx=None, state=None): 88 | if state is None: 89 | state = search_tree.states[idx] 90 | 91 | kernel = state_kernel(env, search_tree.states, state) 92 | w_ = np.sum(kernel) 93 | 94 | return w_ 95 | -------------------------------------------------------------------------------- /environment/maze_env.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from algorithm import RRT_EPS 3 | from .env_config import LIMITS, STICK_LENGTH 4 | 5 | class MazeEnv: 6 | ''' 7 | Interface class for maze environment 8 | ''' 9 | def __init__(self, dim): 10 | print("Initializing environment...") 11 | self.dim = dim 12 | self.collision_check_count = 0 13 | 14 | # load map from file 15 | map_file = 'maze_files/mazes_15_%d_3000.npz' % dim 16 | print("loading mazes from %s" % map_file) 17 | with np.load(map_file) as f: 18 | self.maps = f['maps'] 19 | self.init_states = f['init_states'] 20 | self.goal_states = f['goal_states'] 21 | 22 | self.size = self.maps.shape[0] 23 | self.width = self.maps.shape[1] 24 | self.order = list(range(self.size)) 25 | self.episode_i = 0 26 | 27 | def init_new_problem(self, index=None): 28 | ''' 29 | Initialize a new planning problem 30 | ''' 31 | if index is None: 32 | index = self.episode_i 33 | 34 | self.map = self.maps[self.order[index]] 35 | self.init_state = self.init_states[self.order[index]] 36 | self.goal_state = self.goal_states[self.order[index]] 37 | self.episode_i += 1 38 | self.collision_check_count = 0 39 | 40 | return self.get_problem() 41 | 42 | def get_problem(self): 43 | problem = { 44 | "map": self.map, 45 | "init_state": self.init_state, 46 | "goal_state": self.goal_state 47 | } 48 | return problem 49 | 50 | def uniform_sample(self): 51 | ''' 52 | Uniformlly sample in the configuration space 53 | ''' 54 | sample = np.random.uniform(-LIMITS[:self.dim], LIMITS[:self.dim]) 55 | return sample 56 | 57 | def distance(self, from_state, to_state): 58 | ''' 59 | Distance metric 60 | ''' 61 | diff = np.abs(to_state - from_state) 62 | if diff.ndim == 1: 63 | diff = diff.reshape(1, -1) 64 | 65 | if self.dim >= 3: 66 | diff[:,2] = np.min((diff[:,2], np.abs(diff[:,2] - 2*LIMITS[2])), axis=0) 67 | assert (np.abs(diff[:,2]) <= LIMITS[2]).all() 68 | 69 | return np.sqrt(np.sum(diff**2, axis=-1)) 70 | 71 | def interpolate(self, from_state, to_state, ratio): 72 | diff = to_state - from_state 73 | 74 | if self.dim >= 3: 75 | if np.abs(diff[2]) > LIMITS[2]: 76 | if diff[2] > 0: 77 | diff[2] -= 2*LIMITS[2] 78 | else: 79 | diff[2] += 2*LIMITS[2] 80 | assert np.abs(diff[2]) <= LIMITS[2] 81 | 82 | new_state = from_state + diff * ratio 83 | 84 | if self.dim >= 3: 85 | if np.abs(new_state[2]) > LIMITS[2]: 86 | if new_state[2] > 0: 87 | new_state[2] -= 2*LIMITS[2] 88 | else: 89 | new_state[2] += 2*LIMITS[2] 90 | assert np.abs(new_state[2]) <= LIMITS[2] 91 | 92 | return new_state 93 | 94 | def in_goal_region(self, state): 95 | ''' 96 | Return whether a state(configuration) is in the goal region 97 | ''' 98 | return self.distance(state, self.goal_state) < RRT_EPS and \ 99 | self._state_fp(state) 100 | 101 | def step(self, state, action=None, new_state=None, check_collision=True): 102 | ''' 103 | Collision detection module 104 | ''' 105 | # must specify either action or new_state 106 | if action is not None: 107 | new_state = state + action 108 | 109 | new_state[:2] = new_state[:2].clip(-LIMITS[:-1], LIMITS[:-1]) 110 | if self.dim >= 3: 111 | if np.abs(new_state[2]) > LIMITS[2]: 112 | if new_state[2] > 0: 113 | new_state[2] -= 2*LIMITS[2] 114 | else: 115 | new_state[2] += 2*LIMITS[2] 116 | assert np.abs(new_state[2]) <= LIMITS[2] 117 | 118 | action = new_state - state 119 | 120 | if not check_collision: 121 | return new_state, action 122 | 123 | done = False 124 | no_collision = self._edge_fp(state, new_state) 125 | if no_collision and self.in_goal_region(new_state): 126 | done = True 127 | 128 | return new_state, action, no_collision, done 129 | 130 | #=====================internal collision check module======================= 131 | 132 | # transform a state into a discretized grid coordinate 133 | def _transform(self, state, w=15): 134 | coord = ((np.array(state)[:2].flatten() + 1.0) * w / 2.0).astype(int) 135 | coord[coord > w-1] = w-1 136 | return coord 137 | 138 | def _end_points(coord=None, l=None, center=None, theta=None, a=None,\ 139 | b=None): 140 | if theta is None: 141 | theta = coord[2] / LIMITS[2] * np.pi 142 | orient = np.array([np.cos(theta), np.sin(theta)]) 143 | if l is None: 144 | l = STICK_LENGTH 145 | 146 | if a is None and b is None: 147 | if center is None: 148 | center = np.array(coord[:2]) 149 | a = center - l / 2. * orient 150 | b = center + l / 2. * orient 151 | else: 152 | if a is not None: 153 | b = a + l * orient 154 | if b is not None: 155 | a = b - l * orient 156 | 157 | return a, b 158 | 159 | def _valid_state(self, state): 160 | return (state >= -LIMITS[:state.size]).all() and \ 161 | (state <= LIMITS[:state.size]).all() 162 | 163 | def _point_in_free_space(self, state): 164 | assert state.size == 2 165 | if not self._valid_state(state): 166 | return False 167 | 168 | return self.map[tuple(self._transform(state, self.width))] == 0 169 | 170 | def _stick_in_free_space(self, state): 171 | assert state.size == 3 172 | 173 | if not self._valid_state(state): 174 | return False 175 | 176 | a, b = MazeEnv._end_points(state) 177 | if not self._point_in_free_space(a) or not self._point_in_free_space(b): 178 | return False 179 | 180 | return self._iterative_check_segment(a, b) 181 | 182 | def _state_fp(self, state): 183 | assert state.size == 2 or state.size == 3 or state.size == 5 184 | self.collision_check_count += 1 185 | 186 | if state.size == 2: 187 | return self._point_in_free_space(state) 188 | elif state.size == 3: 189 | return self._stick_in_free_space(state) 190 | 191 | def _iterative_check_segment(self, left, right): 192 | assert left.size == 2 and right.size == 2 193 | 194 | left_coord = np.array(self._transform(left, self.width), dtype=int) 195 | right_coord = np.array(self._transform(right, self.width), dtype=int) 196 | if np.sum(np.abs(left_coord - right_coord)) > 1: 197 | mid = (left + right) / 2.0 198 | if not self._state_fp(mid): 199 | return False 200 | return self._iterative_check_segment(left, mid) and self._iterative_check_segment(mid, right) 201 | 202 | return True 203 | 204 | def _edge_fp(self, state, new_state): 205 | assert state.size == new_state.size 206 | 207 | if not self._valid_state(state) or not self._valid_state(new_state): 208 | return False 209 | if not self._state_fp(state) or not self._state_fp(new_state): 210 | return False 211 | 212 | if state.size == 2: 213 | return self._iterative_check_segment(state, new_state) 214 | else: 215 | 216 | disp = new_state - state 217 | if np.abs(disp[2]) > LIMITS[2]: 218 | if disp[2] > 0: 219 | disp[2] -= 2*LIMITS[2] 220 | else: 221 | disp[2] += 2*LIMITS[2] 222 | assert np.abs(disp[2]) <= LIMITS[2] 223 | 224 | d = self.distance(state, new_state) 225 | K = int(d / 0.015) 226 | for k in range(1, K): 227 | c = state + k*1./K * disp 228 | 229 | if state.size == 3: 230 | ca, cb = MazeEnv._end_points(c) 231 | if not self._edge_fp(ca, cb): 232 | return False 233 | 234 | return True -------------------------------------------------------------------------------- /algorithm/tsa.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import numpy as np 3 | from queue import Queue 4 | from .search_tree import SearchTree, insert_new_state, compute_w, rewire_to, \ 5 | set_cost, update_collision_checks 6 | from .alg_config import RRT_EPS 7 | 8 | def RRTS_plan(env, T=100, stop_when_success=False): 9 | return NEXT_plan(env=env, T=T, g_explore_eps=1., \ 10 | stop_when_success=stop_when_success) 11 | 12 | def NEXT_plan(env, model=None, T=100, g_explore_eps=1., \ 13 | stop_when_success=False, UCB_type='kde'): 14 | """Robot motion planning with NEXT. 15 | 16 | Args: 17 | env: The environment which stores the problem relevant information (map, 18 | initial state, goal state), and performs collision check, goal 19 | region check, uniform sampling. 20 | model: Machine learning model used to guide vertex selection and 21 | tree expansion. 22 | T (int): Maximum number of samples allowed. 23 | g_explore_eps (float): Probability for RRT-like global exploration. 24 | stop_when_success (bool): Whether to terminate the algorithm if one path 25 | is found. 26 | UCB_type (string): Type of UCB used (one of {'kde', 'GP'}). 27 | 28 | Returns: 29 | search_tree: Search tree generated by the algorithm. 30 | success (bool): Whether a path is found. 31 | """ 32 | search_tree = SearchTree( 33 | env = env, 34 | root = env.init_state, 35 | model = model, 36 | dim = env.dim 37 | ) 38 | 39 | success = False 40 | for i in range(T): 41 | leaf_id = None 42 | 43 | # Goal-biased heuristic. 44 | if np.random.rand() < 0.05: 45 | leaf_state, parent_idx, _, no_collision, done = \ 46 | global_explore(search_tree, env, sample_state=env.goal_state) 47 | success = success or done 48 | expanded_by_rrt = True 49 | 50 | # RRT-like global exploration. 51 | elif np.random.rand() < g_explore_eps: 52 | leaf_state, parent_idx, _, no_collision, done = \ 53 | global_explore(search_tree, env) 54 | success = success or done 55 | expanded_by_rrt = True 56 | 57 | # Guided selection and expansion. 58 | else: 59 | idx = select(search_tree, env) 60 | assert search_tree.freesp[idx] 61 | # assert not search_tree.in_goal_region[idx] 62 | 63 | parent_idx = idx 64 | leaf_state, _, no_collision, done = \ 65 | expand(search_tree, parent_idx, model, env) 66 | success = success or done 67 | expanded_by_rrt = False 68 | 69 | leaf_id = insert_new_state(env, search_tree, leaf_state, model, \ 70 | parent_idx, no_collision, done, expanded_by_rrt=expanded_by_rrt) 71 | RRTS_rewire_last(env, search_tree) 72 | 73 | if success and stop_when_success: 74 | break 75 | 76 | print('success =', success, ' number of samples =', i) 77 | 78 | return search_tree, success 79 | 80 | def RRT_steer(env, sample_state, nearest, dist): 81 | """Steer the sampled state to a new state close to the search tree. 82 | 83 | Args: 84 | env: The environment which stores the problem relevant information (map, 85 | initial state, goal state), and performs collision check, goal 86 | region check, uniform sampling. 87 | sample_state: State sampled from some distribution. 88 | nearest: Nearest point in the search tree to the sampled state. 89 | dist: Distance between sample_state and nearest. 90 | 91 | Returns: 92 | new_state: Steered state. 93 | """ 94 | if dist < RRT_EPS: 95 | return sample_state 96 | 97 | ratio = RRT_EPS / dist 98 | return env.interpolate(nearest, sample_state, ratio) 99 | 100 | def global_explore(search_tree, env, sample_state=None): 101 | """One step of RRT-like expansion. 102 | 103 | Args: 104 | search_tree: Current search tree generated by the algorithm. 105 | env: The environment which stores the problem relevant information (map, 106 | initial state, goal state), and performs collision check, goal 107 | region check, uniform sampling. 108 | sample_state: A randomly sampled state (if provided). 109 | 110 | Returns: 111 | new_state: New state being added to the search tree. 112 | parent_idx: Index of the parent of the new state. 113 | action: Path segment connecting parent and new state. 114 | no_collision (bool): True <==> the path segment is collision-free. 115 | done (bool): True <==> the path segment is collision-free and the new 116 | state is inside the goal region. 117 | """ 118 | non_terminal_states = search_tree.non_terminal_states 119 | 120 | # Sample uniformly in the maze 121 | if sample_state is None: 122 | sample_state = env.uniform_sample() 123 | 124 | # Steer sample to nearby location 125 | dists = env.distance(non_terminal_states, sample_state) 126 | nearest_idx, min_dist = np.argmin(dists), np.min(dists) 127 | new_state = RRT_steer(env, sample_state, non_terminal_states[nearest_idx], \ 128 | min_dist) 129 | 130 | new_state, action, no_collision, done = env.step( 131 | state = non_terminal_states[nearest_idx], 132 | new_state = new_state 133 | ) 134 | 135 | return new_state, search_tree.non_terminal_idxes[nearest_idx], action, \ 136 | no_collision, done 137 | 138 | def select(search_tree, env, c=1., use_GP=False): 139 | """Select a point in the search tree for expansion. 140 | 141 | Args: 142 | search_tree: Current search tree generated by the algorithm. 143 | env: The environment which stores the problem relevant information (map, 144 | initial state, goal state), and performs collision check, goal 145 | region check, uniform sampling. 146 | c: Hyperparameter controlling the weight for exploration. 147 | use_GP: True <==> using Gaussian Process. 148 | 149 | Returns: 150 | idx (int): Index of the point in the tree being selected. 151 | """ 152 | scores = [] 153 | for i in range(search_tree.non_terminal_states.shape[0]): 154 | idx = search_tree.non_terminal_idxes[i] 155 | Q = search_tree.state_values[idx] 156 | U = np.sqrt(np.log(search_tree.w_sum) / search_tree.w[idx]) 157 | 158 | scores.append(Q + c*U) 159 | 160 | return search_tree.non_terminal_idxes[np.argmax(scores)] 161 | 162 | def expand(search_tree, idx, model, env, k=10, c=1., use_GP=False): 163 | """Expand a search tree from a given point. 164 | 165 | Args: 166 | search_tree: Current search tree generated by the algorithm. 167 | idx (int): Index of the selected point. 168 | model: Machine learning model used to guide the expansion. 169 | env: The environment which stores the problem relevant information (map, 170 | initial state, goal state), and performs collision check, goal 171 | region check, uniform sampling. 172 | k (int): Number of candidate actions. 173 | c: Hyperparameter controlling the weight for exploration. 174 | use_GP: True <==> using Gaussian Process. 175 | 176 | Returns: 177 | new_state: New state being added to the tree. 178 | action: Path segment connecting parent and new state. 179 | no_collision (bool): True <==> the path segment is collision-free. 180 | done (bool): True <==> the path segment is collision-free and the new 181 | state is inside the goal region. 182 | """ 183 | state = np.array(search_tree.states[idx]) 184 | candidate_actions = model.policy(state=state, k=k)[0] 185 | candidates = [] 186 | for i in range(k): 187 | action = candidate_actions[i] 188 | new_state, _ = env.step(state=state, action=action, \ 189 | check_collision=False) 190 | candidates.append(new_state) 191 | 192 | if k > 1: 193 | scores = [] 194 | Qs = model.pred_value(np.array(candidates)) 195 | for i in range(k): 196 | Q = Qs[i] 197 | w = compute_w(env, search_tree, state=candidates[i]) 198 | U = np.sqrt(np.log(search_tree.w_sum) / w) 199 | scores.append(Q + c*U) 200 | new_state = candidates[np.argmax(scores)] 201 | 202 | else: 203 | new_state = candidates[0] 204 | 205 | new_state, action, no_collision, done = env.step( 206 | state = state, 207 | new_state = new_state 208 | ) 209 | 210 | return new_state, action, no_collision, done 211 | 212 | def RRTS_rewire_last(env, search_tree, neighbor_r=None, obs_cost=2): 213 | """Locally optimize the search tree by rewiring the latest added point. 214 | 215 | Args: 216 | env: The environment which stores the problem relevant information (map, 217 | initial state, goal state), and performs collision check, goal 218 | region check, uniform sampling. 219 | search_tree: Current search tree generated by the algorithm. 220 | neighbor_r (float): Radius for rewiring. 221 | obs_cost (float): Cost for obstacle (hyperparameter). 222 | """ 223 | if neighbor_r is None: 224 | neighbor_r = RRT_EPS*3 225 | cur_tree = search_tree.states[:-1] 226 | new_state = search_tree.states[-1] 227 | nearest = search_tree.parents[-1] 228 | freesp = search_tree.freesp 229 | 230 | # Return if the latest point is inside of an obstacle. 231 | if not search_tree.freesp[-1]: 232 | set_cost(search_tree, -1, obs_cost) 233 | update_collision_checks(search_tree, env.collision_check_count) 234 | return 235 | 236 | # Find the locally optimal path to the root for the latest point. 237 | dists = env.distance(cur_tree, new_state) 238 | near = np.where(dists < neighbor_r)[0] 239 | 240 | min_cost = dists[nearest] + search_tree.costs[nearest] 241 | min_j = nearest 242 | for j in near: 243 | if not freesp[j]: 244 | continue 245 | cost_new = dists[j] + search_tree.costs[j] 246 | if cost_new < min_cost: 247 | _, _, no_collision, done = env.step( 248 | state = cur_tree[j], 249 | new_state = new_state 250 | ) 251 | if no_collision: 252 | min_cost, min_j = cost_new, j 253 | 254 | # Rewire (change parent) to the locally optimal path. 255 | rewire_to(search_tree, -1, min_j) 256 | set_cost(search_tree, -1, min_cost) 257 | 258 | # If the latest point can improve the cost for the neighbors, rewire them. 259 | for j in near: 260 | cost_new = min_cost + dists[j] 261 | if cost_new < search_tree.costs[j]: 262 | _, _, no_collision, done = env.step( 263 | state = cur_tree[j], 264 | new_state = new_state 265 | ) 266 | 267 | if no_collision: 268 | set_cost(search_tree, j, cost_new) 269 | rewire_to(search_tree, j, len(search_tree.states)-1) 270 | 271 | update_collision_checks(search_tree, env.collision_check_count) -------------------------------------------------------------------------------- /model/model.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | import torch 4 | import torch.nn as nn 5 | import torch.nn.functional as F 6 | import torch.optim as optim 7 | from torch.distributions.multivariate_normal import MultivariateNormal 8 | 9 | from algorithm import RRT_EPS 10 | from environment import LIMITS 11 | from utils import load_model 12 | 13 | class Attention(nn.Module): 14 | def __init__(self, cuda=True, env_width=15, cap=8, dim=2): 15 | super(Attention, self).__init__() 16 | self.w = env_width 17 | self.cap = cap 18 | self.dim = dim 19 | self.fix_attention = False 20 | 21 | # coords[0:2, i, j] = [i, j] 22 | # for i, j in {0, 1, ..., w-1} 23 | idx = np.arange(self.w) 24 | col_coord = np.tile(idx, (self.w, 1)) 25 | row_coord = np.tile(idx.reshape(self.w, 1), (1, self.w)) 26 | self.coords = torch.FloatTensor(np.array([col_coord, row_coord])) 27 | self.coords = self.coords.view(1, 2, self.w, self.w) 28 | 29 | # 1x1 conv ~= mlp with shared parameters 30 | self.mlp_share = nn.Sequential( 31 | nn.Conv2d(in_channels=4, out_channels=16, kernel_size=1), 32 | nn.ReLU(), 33 | nn.Conv2d(in_channels=16, out_channels=16, kernel_size=1), 34 | nn.ReLU(), 35 | nn.Conv2d(in_channels=16, out_channels=32, kernel_size=1), 36 | nn.ReLU(), 37 | nn.Conv2d(in_channels=32, out_channels=32, kernel_size=1), 38 | nn.ReLU(), 39 | nn.Conv2d(in_channels=32, out_channels=64, kernel_size=1), 40 | nn.ReLU(), 41 | nn.Conv2d(in_channels=64, out_channels=1, kernel_size=1), 42 | ) 43 | 44 | # 3rd-d attention 45 | self.mlp = nn.Sequential( 46 | nn.Linear(in_features=self.dim, out_features=64), 47 | nn.ReLU(), 48 | nn.Linear(in_features=64, out_features=self.cap), 49 | ) 50 | 51 | if self.fix_attention: 52 | for param in self.parameters(): 53 | param.requires_grad = False 54 | 55 | if cuda: 56 | self.coords = self.coords.cuda() 57 | 58 | def forward(self, inp): 59 | # x[0:b, 0:4, i, j] = [input[0:b, 0], input[0:b, 1], i, j] 60 | # for i, j in {0, 1, ..., w-1} 61 | x = inp[:, 0:2].contiguous().view(inp.shape[0], 2, 1, 1) 62 | x = x.expand(-1, -1, self.w, self.w) 63 | coords = self.coords.expand(x.shape[0], -1, -1, -1) 64 | x = torch.cat((x, coords), dim=1) 65 | 66 | # attention over 2D grid 67 | x = self.mlp_share(x) 68 | x = x.view(x.shape[0], -1) 69 | x = F.softmax(x, dim=-1) 70 | atten_12d = x.view(x.shape[0], 1, -1) 71 | 72 | # attention over the 3rd dimension 73 | # x = inp[:, 2:3] 74 | x = inp 75 | x = self.mlp(x) 76 | x = F.softmax(x, dim=-1) 77 | atten_3d = x.view(x.shape[0], self.cap, 1) 78 | 79 | # combine 2d and 3rd-d attention 80 | x = atten_12d.expand(-1, self.cap, -1) * atten_3d 81 | x = x.view(-1, self.cap, self.w, self.w) 82 | 83 | return x 84 | 85 | class PPN(nn.Module): 86 | def __init__(self, cuda, env_width=15, cap=8, dim=2): 87 | super(PPN, self).__init__() 88 | self.w = env_width 89 | self.cap = cap 90 | self.dim = dim 91 | 92 | self.g = 8 93 | self.latent_dim = self.cap * self.g 94 | self.iters = 20 95 | self.conv_kern = 3 96 | self.conv_pad = int((self.conv_kern - 1.0) / 2) 97 | self.conv_cap = self.cap * 8 98 | 99 | self.hidden = nn.Conv2d(in_channels=self.cap + 1, out_channels=self.latent_dim, kernel_size=3, padding=1) 100 | self.h0 = nn.Conv2d(in_channels=self.latent_dim, out_channels=self.latent_dim, kernel_size=3, padding=1) 101 | self.c0 = nn.Conv2d(in_channels=self.latent_dim, out_channels=self.latent_dim, kernel_size=3, padding=1) 102 | 103 | self.conv = nn.Conv2d(in_channels=self.latent_dim, out_channels=self.conv_cap, kernel_size=self.conv_kern, padding=self.conv_pad) 104 | self.lstm = nn.LSTMCell(self.conv_cap, self.latent_dim) 105 | 106 | self.attention_g = Attention(cuda, env_width=env_width, cap=cap, dim=dim) 107 | self.attention_s = self.attention_g 108 | 109 | self.policy = nn.Sequential( 110 | nn.Linear(in_features=self.g, out_features=128), 111 | nn.ReLU(), 112 | nn.Linear(in_features=128, out_features=64), # 128 / 64 32/32 113 | nn.ReLU(), 114 | nn.Linear(in_features=64, out_features=self.dim+1), 115 | ) 116 | 117 | def forward(self, cur_state, goal_state, maze_map): 118 | cur_state = cur_state.clone().detach() 119 | goal_state = goal_state.clone().detach() 120 | cur_state[:,-1] /= LIMITS[2] 121 | goal_state[:,-1] /= LIMITS[2] 122 | 123 | b_size = maze_map.shape[0] 124 | 125 | goal_atten = self.attention_g(goal_state) # has size [b_size, capacity, map_w, map_w] 126 | maze_map = maze_map.view(b_size, 1, self.w, self.w) 127 | x = torch.cat((maze_map, goal_atten), dim=1) 128 | 129 | h_layer = self.hidden(x) 130 | h0 = self.h0(h_layer).transpose(1, 3).contiguous().view(b_size * self.w**2, self.latent_dim) 131 | c0 = self.c0(h_layer).transpose(1, 3).contiguous().view(b_size * self.w**2, self.latent_dim) 132 | 133 | 134 | last_h, last_c = h0, c0 135 | for _ in range(0, self.iters): 136 | h_map = last_h.view(-1, self.w, self.w, self.latent_dim) 137 | h_map = h_map.transpose(3, 1) 138 | lstm_inp = self.conv(h_map).transpose(1, 3).contiguous().view(-1, self.conv_cap) 139 | last_h, last_c = self.lstm(lstm_inp, (last_h, last_c)) 140 | 141 | 142 | x = last_h.view(b_size, self.w, self.w, self.latent_dim).transpose(3, 1) 143 | x = x.view(b_size, self.g, self.cap, self.w, self.w) 144 | state_atten = self.attention_s(cur_state).view(b_size, 1, self.cap, self.w, self.w) 145 | x = x * state_atten 146 | 147 | x = x.sum(dim=-1).sum(dim=-1).sum(dim=-1) 148 | x = self.policy(x) 149 | 150 | return x 151 | 152 | def pb_forward(self, goal_state, maze_map): 153 | """Compute the problem representation. 154 | 155 | Args: 156 | goal_state: [1, self.dim] 157 | maze_map: [1, self.w, self.w, self.w] 158 | 159 | Returns: 160 | pb_rep: [1, self.g, self.cap, self.w, self.w, self.w] 161 | """ 162 | goal_state = goal_state.clone().detach() 163 | goal_state[:,-1] /= LIMITS[2] 164 | 165 | b_size = maze_map.shape[0] 166 | assert b_size == 1 167 | 168 | goal_atten = self.attention_g(goal_state) # has size [b_size, capacity, map_w, map_w] 169 | maze_map = maze_map.view(b_size, 1, self.w, self.w) 170 | x = torch.cat((maze_map, goal_atten), dim=1) 171 | 172 | h_layer = self.hidden(x) 173 | h0 = self.h0(h_layer).transpose(1, 3).contiguous().view(b_size * self.w**2, self.latent_dim) 174 | c0 = self.c0(h_layer).transpose(1, 3).contiguous().view(b_size * self.w**2, self.latent_dim) 175 | 176 | last_h, last_c = h0, c0 177 | for _ in range(0, self.iters): 178 | h_map = last_h.view(-1, self.w, self.w, self.latent_dim) 179 | h_map = h_map.transpose(3, 1) 180 | lstm_inp = self.conv(h_map).transpose(1, 3).contiguous().view(-1, self.conv_cap) 181 | last_h, last_c = self.lstm(lstm_inp, (last_h, last_c)) 182 | 183 | x = last_h.view(b_size, self.w, self.w, self.latent_dim).transpose(3, 1) 184 | x = x.view(b_size, self.g, self.cap, self.w, self.w) 185 | 186 | return x 187 | 188 | def state_forward(self, cur_states, pb_rep): 189 | """Forward using problem representation. 190 | 191 | Args: 192 | cur_states: [batch_size, self.dim] 193 | pb_rep: [1, self.g, self.cap, self.w, self.w] 194 | 195 | Returns: 196 | [actions, values]: [batch_size, self.dim + 1] 197 | """ 198 | # if self.dim >= 3: 199 | cur_states = cur_states.clone().detach() 200 | cur_states[:,-1] /= LIMITS[2] 201 | 202 | b_size = cur_states.shape[0] 203 | x = pb_rep.expand(b_size, self.g, self.cap, self.w, self.w) 204 | 205 | state_atten = self.attention_s(cur_states).view(b_size, 1, self.cap, self.w, self.w) 206 | x = x * state_atten 207 | 208 | x = x.sum(dim=-1).sum(dim=-1).sum(dim=-1) 209 | x = self.policy(x) 210 | 211 | return x 212 | 213 | 214 | class Model: 215 | def __init__(self, cuda, env_width=15, model_cap=8, dim=2, std=None, UCB_type='kde'): 216 | if std is None: 217 | std = RRT_EPS*0.3 218 | 219 | print("initializing model ...") 220 | self.net = PPN(cuda, env_width=env_width, cap=model_cap, dim=dim) 221 | self.cuda = cuda 222 | if cuda: 223 | self.net = self.net.cuda() 224 | self.std = std 225 | self.dim = dim 226 | self.var = torch.eye(self.dim)*self.std**2 227 | print('dim == ', dim) 228 | 229 | self.env_width=env_width 230 | self.UCB_type = UCB_type 231 | 232 | def set_problem(self, problem): 233 | self.problem = problem 234 | 235 | # compute problem representation 236 | assert self.net 237 | self.maze_map = problem["map"].reshape(1, self.env_width, self.env_width) 238 | self.goal_state = problem["goal_state"].reshape(1, self.dim) 239 | self.maze_map = torch.FloatTensor(self.maze_map) 240 | self.goal_state = torch.FloatTensor(self.goal_state) 241 | if self.cuda: 242 | self.maze_map = self.maze_map.cuda() 243 | self.goal_state = self.goal_state.cuda() 244 | 245 | self.pb_rep = self.net.pb_forward(self.goal_state, self.maze_map) 246 | 247 | def net_forward(self, states): 248 | if states.ndim == 1: 249 | states = states.reshape(1,-1) 250 | 251 | cur_states = torch.FloatTensor(states) 252 | if self.cuda: 253 | cur_states = cur_states.cuda() 254 | 255 | y = self.net.state_forward(cur_states, self.pb_rep) 256 | y = y.data.cpu().numpy() 257 | 258 | pred_actions = y[:, :self.dim] 259 | pred_values = y[:, -1] 260 | 261 | if pred_actions.shape[0] == 1: 262 | pred_actions = pred_actions[0] 263 | pred_values = pred_values[0] 264 | 265 | return pred_actions, pred_values 266 | 267 | def pred_value(self, states): 268 | _, state_values = self.net_forward(states) 269 | 270 | return state_values 271 | 272 | def policy(self, state, k=1): 273 | action_mean, _ = self.net_forward(state) 274 | m = MultivariateNormal(torch.FloatTensor(action_mean), self.var) 275 | 276 | actions = [] 277 | prior_values = [] 278 | 279 | for i in range(k): 280 | action = m.sample() 281 | prior_value = torch.exp(m.log_prob(action)).item() 282 | 283 | actions.append(action.cpu().numpy()) 284 | prior_values.append(prior_value) 285 | 286 | return actions, prior_values 287 | 288 | def get_net(self): 289 | return self.net 290 | 291 | def set_net(self, net): 292 | self.net = net 293 | 294 | 295 | -------------------------------------------------------------------------------- /main.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "from environment import MazeEnv\n", 11 | "from model import Model\n", 12 | "from algorithm import NEXT_plan, RRTS_plan\n", 13 | "from utils import set_random_seed, load_model, plot_tree" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 2, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "set_random_seed(1234)\n", 23 | "cuda = True" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "# 2D Planning" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": {}, 37 | "outputs": [ 38 | { 39 | "name": "stdout", 40 | "output_type": "stream", 41 | "text": [ 42 | "Initializing environment...\n", 43 | "loading mazes from maze_files/mazes_15_2_3000.npz\n", 44 | "initializing model ...\n", 45 | "dim == 2\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "dim = 2\n", 51 | "UCB_type = 'kde'\n", 52 | "environment = MazeEnv(dim = dim)\n", 53 | "model = Model(cuda = cuda, dim = dim)\n", 54 | "model_file = 'trained_models/NEXT_%dd.pt' % dim\n", 55 | "load_model(model.net, model_file, cuda)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 4, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "# Sample a problem from the environment\n", 65 | "pb_idx = 2101 # 0 - 2999\n", 66 | "pb = environment.init_new_problem(pb_idx)\n", 67 | "model.set_problem(pb)" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "## NEXT Algorithm" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 5, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "name": "stdout", 84 | "output_type": "stream", 85 | "text": [ 86 | "success = True number of samples = 86\n" 87 | ] 88 | }, 89 | { 90 | "data": { 91 | "image/png": "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\n", 92 | "text/plain": [ 93 | "
" 94 | ] 95 | }, 96 | "metadata": { 97 | "needs_background": "light" 98 | }, 99 | "output_type": "display_data" 100 | } 101 | ], 102 | "source": [ 103 | "search_tree, done = NEXT_plan(\n", 104 | " env = environment,\n", 105 | " model = model,\n", 106 | " T = 500,\n", 107 | " g_explore_eps = 0.1,\n", 108 | " stop_when_success = True,\n", 109 | " UCB_type = UCB_type\n", 110 | ")\n", 111 | "plot_tree(\n", 112 | " states = search_tree.states,\n", 113 | " parents = search_tree.parents,\n", 114 | " problem = environment.get_problem()\n", 115 | ")" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "## RRT* Algorithm" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 6, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | "success = False number of samples = 999\n" 135 | ] 136 | }, 137 | { 138 | "data": { 139 | "image/png": "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\n", 140 | "text/plain": [ 141 | "
" 142 | ] 143 | }, 144 | "metadata": { 145 | "needs_background": "light" 146 | }, 147 | "output_type": "display_data" 148 | } 149 | ], 150 | "source": [ 151 | "search_tree, done = RRTS_plan(\n", 152 | " env = environment,\n", 153 | " T = 1000,\n", 154 | " stop_when_success = True\n", 155 | ")\n", 156 | "plot_tree(\n", 157 | " states = search_tree.states,\n", 158 | " parents = search_tree.parents,\n", 159 | " problem = environment.get_problem()\n", 160 | ")" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "# 3D Planning" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 7, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "name": "stdout", 177 | "output_type": "stream", 178 | "text": [ 179 | "Initializing environment...\n", 180 | "loading mazes from maze_files/mazes_15_3_3000.npz\n", 181 | "initializing model ...\n", 182 | "dim == 3\n" 183 | ] 184 | } 185 | ], 186 | "source": [ 187 | "dim = 3\n", 188 | "UCB_type = 'kde'\n", 189 | "environment = MazeEnv(dim = dim)\n", 190 | "model = Model(cuda = cuda, dim = dim)\n", 191 | "model_file = 'trained_models/NEXT_%dd.pt' % dim\n", 192 | "load_model(model.net, model_file, cuda)" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 8, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [ 201 | "# Sample a problem from the environment\n", 202 | "pb_idx = 2101 # 0 - 2999\n", 203 | "pb = environment.init_new_problem(pb_idx)\n", 204 | "model.set_problem(pb)" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "## NEXT Algorithm" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": 9, 217 | "metadata": {}, 218 | "outputs": [ 219 | { 220 | "name": "stdout", 221 | "output_type": "stream", 222 | "text": [ 223 | "success = True number of samples = 126\n" 224 | ] 225 | }, 226 | { 227 | "data": { 228 | "image/png": "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\n", 229 | "text/plain": [ 230 | "
" 231 | ] 232 | }, 233 | "metadata": { 234 | "needs_background": "light" 235 | }, 236 | "output_type": "display_data" 237 | } 238 | ], 239 | "source": [ 240 | "search_tree, done = NEXT_plan(\n", 241 | " env = environment,\n", 242 | " model = model,\n", 243 | " T = 500,\n", 244 | " g_explore_eps = 0.1,\n", 245 | " stop_when_success = True,\n", 246 | " UCB_type = UCB_type\n", 247 | ")\n", 248 | "plot_tree(\n", 249 | " states = search_tree.states,\n", 250 | " parents = search_tree.parents,\n", 251 | " problem = environment.get_problem()\n", 252 | ")" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": {}, 258 | "source": [ 259 | "## RRT* Algorithm" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 10, 265 | "metadata": {}, 266 | "outputs": [ 267 | { 268 | "name": "stdout", 269 | "output_type": "stream", 270 | "text": [ 271 | "success = False number of samples = 1999\n" 272 | ] 273 | }, 274 | { 275 | "data": { 276 | "image/png": "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\n", 277 | "text/plain": [ 278 | "
" 279 | ] 280 | }, 281 | "metadata": { 282 | "needs_background": "light" 283 | }, 284 | "output_type": "display_data" 285 | } 286 | ], 287 | "source": [ 288 | "search_tree, done = RRTS_plan(\n", 289 | " env = environment,\n", 290 | " T = 2000,\n", 291 | " stop_when_success = True\n", 292 | ")\n", 293 | "plot_tree(\n", 294 | " states = search_tree.states,\n", 295 | " parents = search_tree.parents,\n", 296 | " problem = environment.get_problem()\n", 297 | ")" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": null, 303 | "metadata": {}, 304 | "outputs": [], 305 | "source": [] 306 | } 307 | ], 308 | "metadata": { 309 | "kernelspec": { 310 | "display_name": "Python 3", 311 | "language": "python", 312 | "name": "python3" 313 | }, 314 | "language_info": { 315 | "codemirror_mode": { 316 | "name": "ipython", 317 | "version": 3 318 | }, 319 | "file_extension": ".py", 320 | "mimetype": "text/x-python", 321 | "name": "python", 322 | "nbconvert_exporter": "python", 323 | "pygments_lexer": "ipython3", 324 | "version": "3.7.2" 325 | } 326 | }, 327 | "nbformat": 4, 328 | "nbformat_minor": 2 329 | } 330 | --------------------------------------------------------------------------------