def run_test(self, problem_fn, planner, search):
print SEPARATOR
print problem_fn.__name__, self.planner, self.search
tamp_problem = problem_fn(p=self.p)
stream_problem = compile_problem(tamp_problem)
print stream_problem
if search == BFS:
search_fn = get_bfs()
elif search == FAST_DOWNWARD:
# 'dijkstra | astar | wastar1 | wastar2 | wastar3 | eager | lazy
search_fn = get_fast_downward('eager')
else:
raise ValueError(search)
if planner == INCREMENTAL:
plan, _ = incremental_planner(stream_problem,
search=search_fn,
waves=True,
frequency=1,
verbose=False)
elif planner == FOCUSED:
plan, _ = simple_focused(stream_problem,
search=search_fn,
check_feasible=False,
greedy=False,
dfs=True,
verbose=False)
else:
raise ValueError(planner)
self.assertTrue(plan is not None)
INCREMENTAL, FOCUSED = 'incremental', 'focused'
DEFAULT_SEARCH_NAME = BFS
if has_fd():
DEFAULT_SEARCH_NAME = FAST_DOWNWARD
elif has_smtplan():
DEFAULT_SEARCH_NAME = SMTPLAN
elif has_ff():
DEFAULT_SEARCH_NAME = FAST_FORWARD
elif has_lapkt():
DEFAULT_SEARCH_NAME = LAPKT
#DEFAULT_SEARCH_NAME = SMTPLAN
#DEFAULT_SEARCH_NAME = TFD
print 'Using', DEFAULT_SEARCH_NAME, 'as the default search implementation'
if DEFAULT_SEARCH_NAME == FAST_DOWNWARD:
DEFAULT_SEARCH = get_fast_downward()
elif DEFAULT_SEARCH_NAME == TFD:
DEFAULT_SEARCH = get_tfd()
elif DEFAULT_SEARCH_NAME == SMTPLAN:
DEFAULT_SEARCH = get_smtplan()
elif DEFAULT_SEARCH_NAME == FAST_FORWARD:
DEFAULT_SEARCH = get_fast_forward()
elif DEFAULT_SEARCH_NAME == LAPKT:
DEFAULT_SEARCH = get_lakpt()
elif DEFAULT_SEARCH_NAME == BFS:
from stripstream.algorithms.search.bfs import get_bfs
DEFAULT_SEARCH = get_bfs()
else:
raise ValueError('Unexpected search type %s' % DEFAULT_SEARCH_NAME)
def solve_continuous_tamp(planner,
search,
visualize,
display,
verbose=False,
deterministic=False):
# if deterministic:
# set_deterministic()
# sample_tamp_problem | sample_grasp_problem | sample_namo_problem
tamp_problem = sample_tamp_problem()
# stream_problem = compile_problem(tamp_problem,
# streams_fn=generative_streams) # constant_streams | implicit_streams |
# generative_streams
stream_problem = compile_problem(tamp_problem)
print stream_problem
viewer = None
if visualize:
viewer = visualize_initial(tamp_problem, stream_problem)
raw_input('Continue?')
# viewer.save('initial')
if search == DEFAULT:
search_fn = DEFAULT_SEARCH
elif search == BFS:
search_fn = get_bfs()
elif search == FAST_DOWNWARD:
# 'dijkstra | astar | wastar1 | wastar2 | wastar3 | eager | lazy
search_fn = get_fast_downward('eager')
else:
raise ValueError(search)
t0 = time()
if planner == INCREMENTAL:
plan, universe = incremental_planner(
stream_problem, search=search_fn, frequency=1,
verbose=verbose) # 1 | 20 | 100 | INF
elif planner == FOCUSED:
#plan, universe = focused_planner(stream_problem, search=search_fn, greedy=False, verbose=verbose)
plan, universe = simple_focused(stream_problem,
search=search_fn,
greedy=True,
optimal=False,
verbose=verbose)
#plan, universe = plan_focused(stream_problem, search=search_fn, greedy=True, optimal=False, verbose=verbose)
else:
raise ValueError(planner)
print SEPARATOR
print 'Planner:', planner
print 'Search:', search
print 'Plan:', convert_plan(plan)
print 'Solved:', plan is not None
print 'Length:', len(plan) if plan is not None else None
print 'Time:', time() - t0
# TODO - sometimes the movement actions, especially for the lazy
# algorithm, screw up in the display for some reason...
if display and plan is not None:
if viewer is None:
viewer = visualize_initial(tamp_problem, stream_problem)
print '\nExecuting'
# TODO - need to return the problem
states = get_states(universe, plan)
for i, state in enumerate(states):
viewer.clear_state()
visualize_atoms(viewer, state)
raw_input('%s) %s?' %
(i, 'Continue' if i != len(states) - 1 else 'Finish'))
elif viewer is not None:
raw_input('\nFinish?')
def solve_countable_tamp(planner, search, visualize, display, verbose=False):
#tamp_problem = get_grasp_problem(p=3) # 10 | 1000
#tamp_problem = get_distract_problem(p=3) # 10 | 1000
#tamp_problem = get_invert_problem(p=3)
tamp_problem = get_shift_problem(p=3)
#tamp_problem = get_distract_place_problem(p=40)
#stream_problem = compile_problem(tamp_problem, stream_fn=generative_streams) # constant_streams | implicit_streams | constant_streams
stream_problem = compile_problem(tamp_problem)
print stream_problem
#stream_problem.operators = stream_problem.convert_axioms_to_effects()
#stream_problem.replace_axioms()
#for action in stream_problem.operators:
# print action.pddl(True)
viewer = None
if visualize:
from stripstream.pddl.examples.countable_tamp.countable_tamp_viewer import CountableTMPViewer
viewer = CountableTMPViewer(1, NUM_POSES, title='State', height=250)
visualize_atoms(viewer, stream_problem.initial_atoms)
raw_input('Continue?')
verbose_search = False
if search == DEFAULT:
search_fn = DEFAULT_SEARCH
elif search == BFS:
search_fn = get_bfs()
elif search == FAST_DOWNWARD:
search_fn = get_fast_downward(
'eager', verbose=verbose_search
) # 'dijkstra | astar | wastar1 | wastar2 | wastar3 | eager | lazy
elif search == FAST_FORWARD:
search_fn = get_fast_forward(verbose=verbose_search)
elif search == LAPKT:
stream_problem.replace_axioms() # TODO - can I automate this process?
search_fn = get_lakpt(verbose=verbose_search)
#elif search == PYPLANNERS:
# search_fn = get_pyplanners(verbose=False)
else:
raise ValueError(search)
t0 = time()
if planner == INCREMENTAL:
plan, universe = incremental_planner(
stream_problem, search=search_fn, frequency=1,
verbose=verbose) # 1 | 20 | 100 | INF
elif planner == FOCUSED:
#plan, universe = focused_planner(stream_problem, search=search_fn, greedy=False, verbose=verbose)
plan, universe = simple_focused(stream_problem,
search=search_fn,
greedy=True,
dfs=True,
verbose=verbose)
#elif planner == 'hierarchy':
# selector = first_selector # first_selector | all_selector
# plan, universe = replan_hierarchy(stream_problem, selector=selector, execute=True, verbose=verbose)
#elif planner == 'simultaneous':
# plan, universe = simultaneous(stream_problem, frequency=frequency, max_time=max_time)
#elif planner == 'progression':
# plan, universe = progression(stream_problem, max_time=max_time)
else:
raise ValueError(planner)
print SEPARATOR
print 'Planner:', planner
print 'Search:', search
print 'Plan:', convert_plan(plan)
print 'Solved:', plan is not None
print 'Length:', len(plan) if plan is not None else None
print 'Time:', time() - t0
#universe.print_statistics()
#universe.print_domain_statistics()
#print SEPARATOR
#print_plan_stats(plan, universe)
if display and plan is not None:
if viewer is None:
# TODO - unify this across the two
from stripstream.pddl.examples.countable_tamp.countable_tamp_viewer import CountableTMPViewer
viewer = CountableTMPViewer(1,
NUM_POSES,
title='State',
height=250)
print '\nExecuting'
states = get_states(universe, plan)
for i, state in enumerate(states):
viewer.clear()
viewer.draw_environment()
visualize_atoms(viewer, state)
raw_input('%s) %s?' %
(i, 'Continue' if i != len(states) - 1 else 'Finish'))
elif viewer is not None:
raw_input('\nFinish?')