def create_environment(self):
problem_env = PaPMoverEnv(self.problem_idx)
openrave_env = problem_env.env
goal_objs = ['square_packing_box1']
goal_region = 'home_region'
problem_env.set_goal(goal_objs, goal_region)
target_object = openrave_env.GetKinBody('square_packing_box1')
set_color(target_object, [1, 0, 0])
return problem_env, openrave_env
def get_problem_env(config, goal_region, goal_objs):
np.random.seed(config.pidx)
random.seed(config.pidx)
if config.domain == 'two_arm_mover':
problem_env = PaPMoverEnv(config.pidx)
[utils.set_color(o, [0.8, 0, 0]) for o in goal_objs]
problem_env.set_goal(goal_objs, goal_region)
elif config.domain == 'one_arm_mover':
problem_env = PaPOneArmMoverEnv(config.pidx)
[utils.set_color(obj, [0.0, 0.0, 0.7]) for obj in problem_env.objects]
[utils.set_color(o, [1.0, 1.0, 0]) for o in goal_objs]
problem_env.set_goal(goal_objs, goal_region)
else:
raise NotImplementedError
return problem_env
def get_problem_env(config):
n_objs_pack = config.n_objs_pack
if config.domain == 'two_arm_mover':
problem_env = PaPMoverEnv(config.pidx)
goal = ['home_region'] + [
obj.GetName() for obj in problem_env.objects[:n_objs_pack]
]
problem_env.set_goal(goal)
elif config.domain == 'one_arm_mover':
problem_env = PaPOneArmMoverEnv(config.pidx)
goal = ['rectangular_packing_box1_region'] + [
obj.GetName() for obj in problem_env.objects[:n_objs_pack]
]
problem_env.set_goal(goal)
else:
raise NotImplementedError
return problem_env
def main():
parameters = parse_mover_problem_parameters()
filename = 'pidx_%d_planner_seed_%d.pkl' % (parameters.pidx, parameters.planner_seed)
save_dir = make_and_get_save_dir(parameters, filename)
set_seed(parameters.pidx)
problem_env = PaPMoverEnv(parameters.pidx)
goal_object_names = [obj.GetName() for obj in problem_env.objects[:parameters.n_objs_pack]]
goal_region_name = [problem_env.regions['home_region'].name]
goal = goal_region_name + goal_object_names
problem_env.set_goal(goal)
goal_entities = goal_object_names + goal_region_name
if parameters.use_shaped_reward:
reward_function = ShapedRewardFunction(problem_env, goal_object_names, goal_region_name[0],
parameters.planning_horizon)
else:
reward_function = GenericRewardFunction(problem_env, goal_object_names, goal_region_name[0],
parameters.planning_horizon)
motion_planner = OperatorBaseMotionPlanner(problem_env, 'prm')
problem_env.set_reward_function(reward_function)
problem_env.set_motion_planner(motion_planner)
learned_q = None
prior_q = None
if parameters.use_learned_q:
learned_q = load_learned_q(parameters, problem_env)
v_fcn = lambda state: -len(get_objects_to_move(state, problem_env))
if parameters.planner == 'mcts':
planner = MCTS(parameters, problem_env, goal_entities, prior_q, learned_q)
elif parameters.planner == 'mcts_with_leaf_strategy':
planner = MCTSWithLeafStrategy(parameters, problem_env, goal_entities, v_fcn, learned_q)
else:
raise NotImplementedError
set_seed(parameters.planner_seed)
search_time_to_reward, plan = planner.search(max_time=parameters.timelimit)
pickle.dump({"search_time_to_reward": search_time_to_reward, 'plan': plan,
'n_nodes': len(planner.tree.get_discrete_nodes())}, open(save_dir+filename, 'wb'))
def get_problem_env(config, goal_region, goal_objs):
n_objs_pack = config.n_objs_pack
if config.domain == 'two_arm_mover':
problem_env = PaPMoverEnv(config.pidx)
# goal = ['home_region'] + [obj.GetName() for obj in problem_env.objects[:n_objs_pack]]
# for obj in problem_env.objects[:n_objs_pack]:
# utils.set_color(obj, [0, 1, 0])
[utils.set_color(o, [0, 0, 0.8]) for o in goal_objs]
# goal = ['home_region'] + ['rectangular_packing_box1', 'rectangular_packing_box2', 'rectangular_packing_box3',
# 'rectangular_packing_box4']
problem_env.set_goal(goal_objs, goal_region)
elif config.domain == 'one_arm_mover':
problem_env = PaPOneArmMoverEnv(config.pidx)
goal = ['rectangular_packing_box1_region'] + [obj.GetName() for obj in problem_env.objects[:n_objs_pack]]
problem_env.set_goal(goal)
else:
raise NotImplementedError
return problem_env
def main():
commit_hash = get_commit_hash()
parameters = parse_mover_problem_parameters()
filename = 'pidx_%d_planner_seed_%d.pkl' % (parameters.pidx,
parameters.planner_seed)
save_dir = make_and_get_save_dir(parameters, filename, commit_hash)
solution_file_name = save_dir + filename
is_problem_solved_before = os.path.isfile(solution_file_name)
print solution_file_name
if is_problem_solved_before and not parameters.f:
print "***************Already solved********************"
with open(solution_file_name, 'rb') as f:
trajectory = pickle.load(f)
tottime = trajectory['search_time_to_reward'][-1][2]
print 'Time: %.2f ' % tottime
sys.exit(-1)
set_seed(parameters.pidx)
problem_env = PaPMoverEnv(parameters.pidx)
goal_objs = [
'square_packing_box1', 'square_packing_box2',
'rectangular_packing_box3', 'rectangular_packing_box4'
]
goal_region = 'home_region'
problem_env.set_goal(goal_objs, goal_region)
goal_entities = goal_objs + [goal_region]
if parameters.use_shaped_reward:
# uses the reward shaping per Ng et al.
reward_function = ShapedRewardFunction(problem_env, goal_objs,
goal_region,
parameters.planning_horizon)
else:
reward_function = GenericRewardFunction(problem_env, goal_objs,
goal_region,
parameters.planning_horizon)
motion_planner = OperatorBaseMotionPlanner(problem_env, 'prm')
problem_env.set_reward_function(reward_function)
problem_env.set_motion_planner(motion_planner)
learned_q = None
prior_q = None
if parameters.use_learned_q:
learned_q = load_learned_q(parameters, problem_env)
v_fcn = lambda state: -len(get_objects_to_move(state, problem_env))
if parameters.planner == 'mcts':
planner = MCTS(parameters, problem_env, goal_entities, prior_q,
learned_q)
elif parameters.planner == 'mcts_with_leaf_strategy':
planner = MCTSWithLeafStrategy(parameters, problem_env, goal_entities,
v_fcn, learned_q)
else:
raise NotImplementedError
set_seed(parameters.planner_seed)
stime = time.time()
search_time_to_reward, n_feasibility_checks, plan = planner.search(
max_time=parameters.timelimit)
tottime = time.time() - stime
print 'Time: %.2f ' % (tottime)
# todo
# save the entire tree
pickle.dump(
{
"search_time_to_reward": search_time_to_reward,
'plan': plan,
'commit_hash': commit_hash,
'n_feasibility_checks': n_feasibility_checks,
'n_nodes': len(planner.tree.get_discrete_nodes())
}, open(save_dir + filename, 'wb'))